刘沙河 刘沙河
首页
  • Go语言基础

    • 数据类型
    • 反射
    • Go指针
  • Go语言进阶

    • go泛型
    • go条件编译
    • cgo教程
    • Go协程调度原理及GPM模型
    • Go内存管理
    • Go垃圾回收机制
    • Go语言内存对齐
  • Go语言实现原理

    • channel 实现原理
    • slice 实现原理
    • map 实现原理
    • sync.Mutex 实现原理
    • 乐观锁CAS 实现原理
    • singlefight 实现原理
  • gin框架

    • gin中间件原理
    • gin路由原理
  • gorm

    • GORM介绍和使用
    • GORM_CURD操作指南
  • go测试

    • benchmark基准测试
    • pprof 性能分析
  • python进阶

    • Numpy&Pandas
    • celery分布式任务队列
  • Django

    • Django 常见命令
    • middleware中间件
    • Django缓存系统
    • Django信号系统
    • Django REST Framework
  • Flask

    • Flask基础知识总结
    • Flask-SQLAlchemy
  • 爬虫

    • aiohttp
    • scrapy框架
  • Mysql

    • Mysql存储引擎和索引
    • MySQL主从复制
    • Mysql读写分离
    • 数据库分库分表
    • Mysql锁
    • Mysql事务和MVCC原理
    • 分库分表带来的读扩散问题
  • Redis

    • redis基础和数据类型
    • redis主从架构
    • redis哨兵架构
    • redis集群模式
    • 如何保证缓存和数据库双写一致
    • redis底层数据结构
    • redis分布式锁
  • Elasticsearch

    • es基本概念
    • es基础语法
    • es倒排索引
  • etcd

    • Go操作etcd
    • Raft原理
    • etcd分布式锁
  • kafka

    • 消息队列MQ总结
    • kafka 概述及原理
    • kafka 消费问题记录
    • 零拷贝技术
    • kafka分区规范
  • RabbitMQ

    • rabbitMQ基础
    • Go操作rabbitmq
  • RocketMQ

    • 可靠消息队列 rocketMQ
  • Http&Https

    • http&https
    • TCP和UDP
    • Ping 原理
  • RPC

    • RPC初识
    • grpc初识和实现
  • gRPC

    • grpc 初识
    • grpc 上下文 metadata
    • grpc 健康检查
    • grpc keepalive
    • grpc 命名解析
    • grpc 中间件&拦截器
    • grpc 负载均衡
    • grpc 身份认证
    • grpc 超时重试
    • grpc 链路追踪
    • grpc-gw将gRPC转RESTfu api
    • grpc-gw自定义选项
  • protobuf

    • protobuf 进阶
    • protobuf 编码原理
  • Docker

    • Docker基础
    • Docker常用命令
    • Dockerfile
    • Docker-Compose
    • Docker多阶段构建
    • Docker Config 教程
    • Docker Swarm 教程
    • Docker Stack 教程
    • Docker Buildx 教程
  • k8s

    • k8s 基础概念
    • k8s 集群架构
    • k8s 工作负载
    • Pod 网络
    • Service 网络
    • 外部接入网络
    • 一张图搞懂k8s各种pod
    • k8s 存储抽象
    • mac快速启动k8s
    • 自制申威架构k8s-reloader
  • go-kit

    • go-kit初识
    • go-kit启动http服务
    • go-kit集成gin启动服务
    • go-kit集成grpc和protobuf
    • go-kit中间件
    • go-kit服务注册发现与负载均衡
    • go-kit限流和熔断
    • go-kit链路追踪
    • go-kit集成Prometheus
  • 设计模式

    • 初识设计模式
    • 创建型模式
    • 结构型模式
    • 行为模式
  • 数据结构

    • 时间轮
    • 堆、双向链表、环形队列
    • 队列:优先队列
    • 队列:延迟队列
  • 算法

    • 递归算法
    • 枚举算法
    • 动态规划
    • 回溯算法
    • 分治算法
    • 贪心算法
    • LRU和LFU
    • 一致性哈希

花开半夏,半夏花开
首页
  • Go语言基础

    • 数据类型
    • 反射
    • Go指针
  • Go语言进阶

    • go泛型
    • go条件编译
    • cgo教程
    • Go协程调度原理及GPM模型
    • Go内存管理
    • Go垃圾回收机制
    • Go语言内存对齐
  • Go语言实现原理

    • channel 实现原理
    • slice 实现原理
    • map 实现原理
    • sync.Mutex 实现原理
    • 乐观锁CAS 实现原理
    • singlefight 实现原理
  • gin框架

    • gin中间件原理
    • gin路由原理
  • gorm

    • GORM介绍和使用
    • GORM_CURD操作指南
  • go测试

    • benchmark基准测试
    • pprof 性能分析
  • python进阶

    • Numpy&Pandas
    • celery分布式任务队列
  • Django

    • Django 常见命令
    • middleware中间件
    • Django缓存系统
    • Django信号系统
    • Django REST Framework
  • Flask

    • Flask基础知识总结
    • Flask-SQLAlchemy
  • 爬虫

    • aiohttp
    • scrapy框架
  • Mysql

    • Mysql存储引擎和索引
    • MySQL主从复制
    • Mysql读写分离
    • 数据库分库分表
    • Mysql锁
    • Mysql事务和MVCC原理
    • 分库分表带来的读扩散问题
  • Redis

    • redis基础和数据类型
    • redis主从架构
    • redis哨兵架构
    • redis集群模式
    • 如何保证缓存和数据库双写一致
    • redis底层数据结构
    • redis分布式锁
  • Elasticsearch

    • es基本概念
    • es基础语法
    • es倒排索引
  • etcd

    • Go操作etcd
    • Raft原理
    • etcd分布式锁
  • kafka

    • 消息队列MQ总结
    • kafka 概述及原理
    • kafka 消费问题记录
    • 零拷贝技术
    • kafka分区规范
  • RabbitMQ

    • rabbitMQ基础
    • Go操作rabbitmq
  • RocketMQ

    • 可靠消息队列 rocketMQ
  • Http&Https

    • http&https
    • TCP和UDP
    • Ping 原理
  • RPC

    • RPC初识
    • grpc初识和实现
  • gRPC

    • grpc 初识
    • grpc 上下文 metadata
    • grpc 健康检查
    • grpc keepalive
    • grpc 命名解析
    • grpc 中间件&拦截器
    • grpc 负载均衡
    • grpc 身份认证
    • grpc 超时重试
    • grpc 链路追踪
    • grpc-gw将gRPC转RESTfu api
    • grpc-gw自定义选项
  • protobuf

    • protobuf 进阶
    • protobuf 编码原理
  • Docker

    • Docker基础
    • Docker常用命令
    • Dockerfile
    • Docker-Compose
    • Docker多阶段构建
    • Docker Config 教程
    • Docker Swarm 教程
    • Docker Stack 教程
    • Docker Buildx 教程
  • k8s

    • k8s 基础概念
    • k8s 集群架构
    • k8s 工作负载
    • Pod 网络
    • Service 网络
    • 外部接入网络
    • 一张图搞懂k8s各种pod
    • k8s 存储抽象
    • mac快速启动k8s
    • 自制申威架构k8s-reloader
  • go-kit

    • go-kit初识
    • go-kit启动http服务
    • go-kit集成gin启动服务
    • go-kit集成grpc和protobuf
    • go-kit中间件
    • go-kit服务注册发现与负载均衡
    • go-kit限流和熔断
    • go-kit链路追踪
    • go-kit集成Prometheus
  • 设计模式

    • 初识设计模式
    • 创建型模式
    • 结构型模式
    • 行为模式
  • 数据结构

    • 时间轮
    • 堆、双向链表、环形队列
    • 队列:优先队列
    • 队列:延迟队列
  • 算法

    • 递归算法
    • 枚举算法
    • 动态规划
    • 回溯算法
    • 分治算法
    • 贪心算法
    • LRU和LFU
    • 一致性哈希
  • Python基础

    • 运算符-while循环
    • 数据类型
    • 知识补充&数据类型列表,元祖
      • 1.知识补充
        • 1.编译型/解释型
        • 2.代码文档头文件
        • 3.补充操作
        • 4.切片/索引取值
        • 5.步长
        • 6.for循环(公共功能)
        • 7.range界限
        • 8.其他(git)
      • 重点总结
      • 2.数据类型
        • 1.列表 list['元素1','元素2',] 万物皆可存
        • 公共功能
        • 列表独有功能
        • 2.列表的嵌套
        • 列表小结
      • 3.元组(tuple)
        • 1.公共功能
        • 2.元组专用功能(无)
    • 字典
    • 数据类型-集合
    • 深浅拷贝&文件操作
    • 文件操作Ⅱ
    • 函数Ⅰ(基础)
    • 函数Ⅱ(参数&作用域)
    • 函数Ⅲ(内置函数&lambda表达式)
    • 函数Ⅳ(闭包&内置模块)
    • 装饰器&推导式
    • 装饰器(二)&模块(一)
    • 模块(二)
    • 模块(总)
    • 迭代器&生成器
    • 面向对象(一)
    • 面向对象(二)类成员&成员修饰符
    • 面向对象(三)特殊方法
    • 面向对象(四) 约束&反射
    • 正则表达式
    • re模块
  • Python进阶

  • Python并发编程

  • Django

  • Flask

  • 爬虫

  • Python
  • Python基础
bigox
2022-06-16
目录

知识补充&数据类型列表,元祖

# 4.1知识补充&数据类型:列表,元祖

# 1.知识补充

# 1.编译型/解释型

  • 编译型:在代码编写完成之后编译器将其变成另外一个文件教给你算计执行.

    代表语言:Java,c,c++ ,c#, Go...

  • 解释型:写完代码后交给解释器,解释器从上到下一行行代码执行:边解释边执行.(实时翻译)

    代表语言:python, PHP, JavaScript...

# 2.代码文档头文件

#!/usr/bin/env python     (解释器路径)

# -*- conding:utf-8 -*-   (默认解释器编码为utf-8)
1
2
3

# 3.补充操作

  • .startswith() 判断是否以()开头,输出值为bool类型

    name = 'bigox'
    print(name.startswith('big'))
    
    1
    2
  • .endswith() 同.startswith()用法相同

  • .format()格式(同字符串格式化)

    举例:

    name = '我叫:{0},年龄:{1}'.format('bigox',24)
    print(name)
    
    1
    2
  • .encode() :编码转换

    name  = '刘'              #解释器读取到内存后,按照unicode编码存储:8字节.
    
    print(name.encode('utf-8'))    #转化为utf-8编码
    
    1
    2
    3
  • .join()循环每个元素,并在元素之间加入连接符.

    name = 'bigox'
    new_name = '_'.join(name)
    print(new_name)       #输出结果为  b_i_g_o_x
    
    1
    2
    3

# 4.切片/索引取值

  • 切片:获取一个字符串(子序列)
  • 索引:取值获取一个字符

# 5.步长

  • 切片显示长度

    name = 'bigox'
    val1 = name[0:5:2]    
    print (val1)   #========>>bgx
    #--------面试题---------
    name = 'bigox'
    print(name[::-1])   #翻转输出name====>xogib
    
    1
    2
    3
    4
    5
    6

# 6.for循环(公共功能)

  • for循环基本结构

    for 新变量 in 原变量:

    ​ 结果 ----------------循环取出原变量的字符赋值给新变量

name = 'bigox'
for new_name in name:
    print(new_name)
1
2
3
  • for循环中break和continue用法一样
  • 在使用循环中,有穷尽的优先考虑for循环,无穷尽的考虑while循环

# 7.range界限

#  range(1,5,1)    #第一个参数是范围的起始位置,第二个参数是范围的结束位置,第三个为步长,默认为1,取值顾首不顾尾.
for num in range(1,9):
	print(num)          #=======>输出为1-8
1
2
3

# 8.其他(git)

将代码提交到远程 仓库

  • 初始化

    • 进入一个任意文件夹,如:D:\homework\

    • git init #接管文件夹

    • git config 邮箱

    • git config 姓名

    • git remote add origin https://gitee.com/old_boy_python_stack_21/190 326032.git

      注意:至此git已经将 D:\homework\目录管理起来,以后此文件夹有任何 变化,git都会检测到(使用 git status 命令可以查看状态)

  • 代码收集并提交

    • git status #检查更新
    • git add .
    • git commit -m ''记录" #创建记录说明
    • git push origin master #将本地D:\homework\目录下的内容同步到 码云仓 库。
  • 修改代码或删除文件等对本地 D:\homework\ 下任何文件做操作。

    • git status
    • git add .
    • git commit -m ''记录"
    • git push origin master 将本地D:\homework\目录下的内容同步到 码云仓 库。
  • 【避免】如果远程有本地没有的代码,必须先执行:【可能引发合并问题】

    • git pull origin master
    • git status
    • git add .
    • git commit -m ''记录"
    • git push origin master 将本地D:\homework\目录下的内容同步到 码云仓 库。

# 重点总结

必须掌握要点:

  1. 变量/if/while
  2. 字符串的独有功能, 公共功能, for循环
  3. 逻辑 + 代码

# 2.数据类型

# 1.列表 list['元素1','元素2',] 万物皆可存

# 公共功能

  • len()

  • 索引(与字符串类似)

    lit = ['6','我','的',66]
    print(lit[3])   #66
    
    1
    2
  • 切片

  • 步长

  • for循环(列表元素是什么类型循环的结果对应不变)

    lit = ['6','我','的',66]
    for i in lit:
        print(type(i))   #输出为str ,str  ,str  ,int
    
    1
    2
    3
  • for循环加序号

    name = ['韩红','周杰伦','刘德华','bigox']
    length = len(name)
    for lit in range(0,length):
        print(lit,name[lit])
    
    1
    2
    3
    4
  1. 删除(注意要点:字符串不可用,字符串本身不能修改或者删除.)

    • .pop(索引)

      a = li.pop(2) #在列表中删除,并将删除的此数据赋值给a

    • del 列表 [索引]

    name = ['bigox','xo','ox']
    #pop
    name.pop(1)
    print(name)
    #del
    del name[0:2]
    print(name)
    
    1
    2
    3
    4
    5
    6
    7
  • 可变类型:list
  • 不可变类型:str/int/bool

# 列表独有功能

  1. 列表最后追加元素 .append()

    lst = ["麻花藤", "林俊杰", "周润发", "周芷若"] 
    print(lst) 
    lst.append("wusir") 
    print(lst)
    
    1
    2
    3
    4
  2. .insert在指定的索引位置插入元素

    lst = ["麻花藤", "林俊杰", "周润发", "周芷若"] 
    print(lst) 
    lst.insert(1,"wusir") 
    print(lst)
    
    1
    2
    3
    4
  3. **.remove()**指定元素删除

    .remove("指定元素")

  4. **.pop()**删除索引元素:()如果没有索引值的话默认删除出最后一个

    .pop(索引)

  5. **.clear()**清空

  6. .extend()添加

    li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
    s = 'qwert'
    li.extend(s)
    print(li)
    #---------------------------
    lst = ["王志文", "张一山", "苦海无涯"]
    lst.extend(["麻花藤", "麻花不疼"])
    print(lst)
    
    1
    2
    3
    4
    5
    6
    7
    8

# 2.列表的嵌套

  • 列表里可以存列表

# 列表小结

  • 增

    append/insert

  • 删

    pop/del/clear

  • 改

    users[1]= ‘新值’

  • 查

    索引/切片

  • 嵌套

# 3.元组(tuple)

  • 元组为不可变类型

# 1.公共功能

  • 索引
  • 切片
  • 步长
  • 删除(可变类型)
  • 修改(可变类型)
  • for循环
  • len

# 2.元组专用功能(无)

  • 元组子元素不可变,而子元素内部的子元素是可以变的,取决于元素是否为可变对象
  • 元组中如果只有一个元素,一定要添加一个逗号,否者不是元组
  • 可嵌套
#Python#
上次更新: 2023/04/16, 18:35:33
数据类型
字典

← 数据类型 字典→

最近更新
01
go与http代理
05-24
02
自制申威架构k8s-reloader
12-06
03
Docker Buildx 教程
12-01
更多文章>
Theme by Vdoing | Copyright © 2020-2024 小刘扎扎 | MIT License
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式