python基础数据类型
数字
没啥可说的，不可变类型
布尔值
各种数据类型的布尔值：
数据类型 | 数字 | 字符串 | 列表 | 字典 | 元组 | 集合 |
True | 非0 | 非空 | 非空 | 非空 | 非空 | 非空 |
False | 0 | 空 | 空 | 空 | 空 | 空 |
字符串
- 索引
要点：下表是位置-1，从0开始
- 切片
语法：s[开始:结束：步长]
a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长
- 字符串方法
s='sdds'
# s.strip() #去除两边的空格（默认，可以执行去除的东西，lstrip和rstrip为左右去除）
# s.replace() #将...替换为...
# s.upper() #全体大写
# s.lower() #全体小写
# s.capitalize() #首字母大写
# s.swapcase() #大小写反转
# s.isdigit() #数字判断，返回布尔值
# s.isalnum() #数字/字母判断，返回布尔值
# s.isalpha() #字母判断，返回布尔值
# s.startswith() #以...开头，返回布尔值
# s.endswith() #以...结尾，返回布尔值
# s.count() #出现次数计数
# s.find() #...是否存在，存在返回第一次匹配到的下标，反之返回-1
# s.index() #...是否存在，存在返回第一次匹配到的下标，反之报错
# s.split() #以...分割，形成一个列表 str————list转化因为字符串是不可变类型，所以执行字符串方法只是产生了新的字符串，需要变量接收或者print
- 格式化输出
res = ('%s%d'%('sks',12)) #占位符式
res = '{} {} {}'.format('egon',18,'male') #format式（推荐）
res = '{1} {0} {1}'.format('egon',18,'male')
res = '{name} {age} {sex}'.format(sex='male',name='egon',age=18)列表
- 切片
列表的切片和字符串原理相同
- 增删改查
list = [1,2,3,4]
#增
list.append(111) #增加到最后
list.insert(0,55) #按照索引位置添加
list.extend([1,2,3]) #将可迭代对象循环添加
list.extend('asdas')
#删
list.pop(1) #按照索引删除，可以接收返回值
del list[2] #可以按照索引删除，也可以切片删除，没有返回值
list.remove(3) #按照元素去删除
list.clear() #清除列表
#改
list[2] = 'sss' #直接根据索引改
list[1:3] = ['asd','a'] #切片改
#查
#切片或者循环去查
#方法
list.count() #计数
list.index('s') #返回第一个匹配到的索引值，和字符串用法一样，但是列表没有find方法
list.sort() #排序
list.reverse() #列表反转由于列表是可变类型，所以执行增删改一类的方法后列表直接发生了变化，不需要返回值接收。
字典
字典是可变类型的，但是key必须是不可变类型的
dict = {'k1':'v1','k2':'v2','k3':'v3'}
#增
dict.setdefault('k3','v4') #增加，如果已有不会更改或覆盖
dict.setdefault('k4') #不写值默认为none
#删
dict.pop('k3') #删除键值对，返回值
dict.pop('k4','none') #如果没有相应的key则返回后边的自定义值，没有自定义值报错
del dict['k1'] #删除相应键值对，没有返回值
dict.popitem() #随机删除某个键值对，返回值是元组
#改
dict['k1'] = 'aaa' #根据key直接赋值改
dict.update(dict2) #将另一个字典覆盖添加到dict，有改，没有添加
#查
print(dict['k1']) #根据key直接查
dict.get('k1','aaa') #有则返回值，没有返回给定值，没有给定值则返回none
#方法
dict.items() #dict_items([('k3', 'v3'), ('k2', 'v2'), ('k1', 'v1')])
dict.keys() #dict_keys(['k1', 'k2', 'k3'])
dict.values() #dict_values(['v3', 'v2', 'v1'])
#字典循环
for key in dict: #k1,k2,k3
print(key)
for item in dict.items(): #('k1','v1') ('k2','v2') ('k3','v3')
print(item)
for value in dict.values(): #v1,v2,v3
print(value)
for key,value in dict.items(): #k1 v1 k2 v2 k3 v3
print(key,value)
集合
集合是无序不重复的，集合本身是可变类型，但集合的元素必须是不可变类型的
set1 = {1,2,4} #使用大括号表示集合，set()创建空集合，不能用{},这是空字典
set2 = set()
#增
set2.add('sss')
set2.update('asd') #迭代添加
#删
set1.remove('sss') #删除一个指定元素
set1.pop() #随机删除一个元素
set1.clear() #清空集合
del set1 #删除集合
set1 & set2 #交集
set1 | set2 #并集
set1 - set2 #差集
set1 ^ set2 #反差集
set1.issubset(set2) #判断set1是不是set2的子集
set1.issuperset(set2) #判断set1是不是set2的超集
s = frozenset('batty') #创建不可变集合
数据类型的总结
按存储空间划分：
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数划分：
标量/原子类型：数字，字符串
容器：列表，元组，字典
按可变不可变划分：
可变：列表，字典
不可变：数字，字符串，元组，布尔值
range：用法和切片法则类似
深浅copy
浅拷贝
l1 = [1,2,['alex','wusir']]
l2 = l1.copy() #浅拷贝
print(l1,id(l1)) #[1, 2, ['alex', 'wusir']] 2653607861064
print(l2,id(l2)) #[1, 2, ['alex', 'wusir']] 2653607920136
print(l1[0],id(l1[0])) #1 1740767728
print(l2[0],id(l2[0])) #1 1740767728
l1[1] = 'bob' #源改变，拷贝得到的第一层不变，但是深层会变
print(l1,l2) #[1, 'bob', ['alex', 'wusir']] [1, 2, ['alex', 'wusir']]
l1[2][0] = 'tom'
print(l1,l2) #[1, 'bob', ['tom', 'wusir']] [1, 2, ['tom', 'wusir']]
对于浅拷贝，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。深拷贝
import copy
l3 = [1,2,['alex','wusir']]
l4 = copy.deepcopy(l3) #深拷贝，需要引入copy模块
深拷贝，两个完全独立，一个不随着另一个的改变而改变
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
