1. 整型（int）
1.1 其它类型转换为整型
可以通过 type() 来查看变量到底是什么类型
# 布尔值转整型 n1 = int(True) # True转换为整数 1 n2 = int(False) # False转换为整数 0
# 字符串转整型 v1 = int("186", base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186 v2 = int("0b1001", base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制) v3 = int("0o144", base=8) # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制) v4 = int("0x59", base=16) # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）
1.2 Py2和Py3的差异
Python2中有int、long（长整型），长整型都以L结尾
- int，可表示的范围：-9223372036854775808～9223372036854775807
- long，整数值超出int范围之后自动会转换为long类型（无限制）
Python3中只剩下：int（整型），并且 int 长度不在限制
python2中两个值相除时，默认进行地板除，只保留整数位（python3中默认会保留小数）
2. 布尔值（bool）
布尔值True和False的判断
- 整数0、空字符串、空列表、空元祖、空字典转换为布尔值时均为False
- 其他均为True
3. 字符串（str）
3.1 可变类型和不可变类型
可变数据类型：在python中定义一个变量，当变量值被修改后，内存地址没有改变，则该数据定义为可变数据类型。（可以用id来查看）
不可变数据类型：当变量的值被修改后，变量的内存地址发生变更（创建了新对象），则认为该类型为不可变数据类型。
3.2 字符串处理的相关方法
1）大小写相关，得到的都是一个新的字符串
- swapcase()
- upper()
- lower()
- casefold()
- title()
- capitalize()
2）开头结尾字符判断，得到一个布尔值
- endswith()
- startswith()
3）去除字符串两边的内容，得到一个新的字符串
- strip()
4）查找统计
- find()
- index()
- count()
- len()
5）替换分割
- replace()
- partition()
- split()，字符串切割，得到的是一个列表
- splitlines()
- join()
6）类型判断，返回布尔值
- isdigit()
- isalpha()
- isalnum()
- isspace()
7）其他
- expandtabs(15)
- range(0,20,2)
3.3 字符串处理代码示例代码
name = " hgAlexHgzero wuzhihao " print("大小写转换效果：") print(name.capitalize()) # 首字母大写 print(name.swapcase()) # 将字符串中的大小写互换 print(name.title()) # 字符串中的每个单词首字母大写 print(name.upper()) # 全部变大写 print(name.lower()) # 全部变小写,只能转换26个英文字母 print(name.casefold()) # 更为牛逼的全部变小写,不光支持26个英文字母，还支持其他非字母 print("*"*80) print("判断开头结尾：") print(name.endswith("zero")) # 判断是否以zero字符串结尾 print(name.startswith("hg")) # 判断是否以hg字符串开头 print("*"*80) print("strip效果：") print(name.strip()) # 剔除字符串两端的空白 print(name.rstrip()) # 剔除字符串右边的空白 print(name.lstrip()) #剔除字符串左边的空白 print("*"*80) print("查找find和index ：") print(name.find("A")) # 查找A，返回其索引，若找不到，则返回-1 # index 和 find 都有从左和从右开始找的方法，rfind() lfind() rindex() lindex() print("index为：",name.index("A")) # 返回字符串的索引值，若找不到则返回错误 print("统计数量") name.count("hgzero",3,9) # 在3到9的位置计数hgzero出现的次数 print("*"*80) print("特殊效果：") print(name.center(50,"*")) # 将字符串放于50个字符内容的中间，其他空缺内容用*符号补充 print(name.ljust(20,"-")) # 占用20个字符串空位，name字符串靠左，未填满则用-补充 print(name.rjust(20,"-")) # 与ljust类似，name字符串靠右 print(name.zfill(20)) # 占用20个字符串空位，name字符串未占用的空位则在前面补0 print("*"*80) print("replace效果：") print(name.replace("zero","Wuzhihao")) # 用第二个参数来替换第一个参数，但是不会改变原来的字符串，只作为一次结果 # replace()的第三个参数表示要替换的次数,若不指定则表示替换所有 print("*" * 80) # 可用变量来接受这一次的结果 print("partition效果：") print(name.partition("zero")) # 以zero将整个字符串分成3部分 zero前，zero，zero后 保存为列表 print("*"*80) print("split效果：") print(name.split("H")) # 按照H字符将整个字符串进行切割，切割后H字符消失，切割后内容保存为列表形式 print(name.splitlines()) # 按照行分隔，返回一个包含各行作为元素的列表，按换行来切割 print("*"*80) # 注意，split()不加参数默认以空格切割，加参数不能为空，就是说貌似split不能对asdfadf这样的字符串进行每个字符的切割 print("join效果：") b = "-" print(b.join(name)) # 将字符串b 插入到字符串变量name中的每个字符之间，形成一个新的字符串 print("*".join(name)) print("*"*80) print("字符串类型判断：") print(name.isdigit()) # 判断所有字符是否是字符 print(name.isalpha()) # 判断所有字符是否为字母 print(name.isalnum()) # 判断所有字符是否为数字和字母的组合 print(name.isspace()) # 判断是否为纯空格 print("*"*80) print("expandtabs方法的使用：") like = "name:wuzhihao age:20 addr:China " print(like.expandtabs(15)) # 每次以15个字符位为一单位，直至出现 ，每一单位中的除了字符串的空白位用空格填充 print(" 7个基本魔法：join() , split() , find() , strip() , lower() , upper() , replace() ") print(" "*3) love = "I love you forever" print(len(love)) # 获取字符串的长度 print(love[4]) # 通过下标的方法截取字符串 print(love[2:6]) # 通过切片的方式截取字符串 print("range方法") print(range(0, 20, 2)) # 以2为步长(每隔一个数)，打印在0到20的范围内(不包括20)的值 # python2中range方法立即创建，而python3中range只在要循环迭代的时候才创建
3.4 字符串的其他内容
1）字符串拼接
2）字符串格式化
4. 列表（list）
4.1 列表类型说明
列表为可变数据类型，且列表是有序的。
- 可变数据类型（mutable）：列表、字典、集合。
- 不可变数据类型（unmutable）：数字、字符串、元组。
可迭代对象：字符串、列表、元组、字典、集合。
4.2 列表的常用方法
1）切片
- name[0:4]，name[0:4:2]，name[:4]，name[1:]，name[:-1]
2）增加
- append()
- insert()
3）扩展
- extend()
4）删除
- del name[2]
- remove()
- pop()
5）修改
- name[2]='two'
- name[3:6]=['first','second','third']
6）查找、统计
- index()
- count()
7）排序、翻转
- sort()
- reverse()
8）深浅copy（要导入copy模块）
- copy()
- deepcopy()
4.3 深浅copy
1）浅拷贝
对可变对象而言，对象的值一样可能包含有其他对象的引用；浅拷贝产生新的对象，虽然具有完全不同的id，但是其值若包含可变对象，这些对象和原始对象中的值包含同样的引用。
也就是说，浅拷贝只拷贝了一层，若子层内还有其他引用，则只拷贝引用的链接。
2）深拷贝
深拷贝不仅仅拷贝了原始对象自身，也对其包含的值进行拷贝，它会递归的查找对象中包含的其他对象的应用，来完成更深层次拷贝。
深拷贝产生的副本可以随意修改而不需要担心引起原始值的改变。
import copy a = copy.copy(b) # 对b进行浅copy后赋值给a，浅拷贝 c = copy.deepcopy(d) # 深拷贝 # copy.copy() 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。 # copy.deepcopy() 深拷贝 拷贝对象及其子对象 v = names.copy() print(v)
4.4 列表常用方法示例代码
names = ['hgzero', 'wuzhihao', 'zero', 'wuzhihao', 'hg', 'hao'] print("切片操作") print(names[0:4]) # 列表的切片操作不包括最后一个值 print(names[0:4:2]) # 切片的第三个参数代表 每隔1个数取一个值 print(names[:4]) print(names[1:]) print(names[:-1]) # 取值不包括最后一个值 print("#" * 50) print("三种增加的方法：") print("追加") names.append("wu") # 在列表尾部追加 names.append("zhi") names.append("hao") print(names) print("插入") names.insert(2, "插入的值") # 在2索引的位置插入要添加的值 print(names) print("扩展") b = [1, 2, 3, 5, 9, 7, 8] names.extend(b) # 将b列表合并到names列表中（尾部添加），形成一个新的列表 print(names) print("三种删除的方法") del names[2] del names[3:5] print(names) names.remove("hgzero") # 删除指定的元素 print(names) names.pop() # 删除列表的最后一个值并返回删除的值，也可加上参数表示删除指定的索引的值并返回删除的值 print(names) print("修改") names[2] = "修改的值" names[3:6] = ["first", "second", "thrid"] # 批量修改 print(names) print("获取下标") print(names.index("wuzhihao")) # 只返回找到的第一个下标 print("统计") print(names.count("wuzhihao")) print("排序和翻转") b.sort() # 排序 print(b) b.reverse() # 反转 print(b)print("清空") names.clear() print(names)
5. 元组（tuple）
5.1 元组类型说明
元组和列表差不多，但是元组一旦创建，就不能再修改（增加、修改、删除），所以元组又叫只读列表。
元组不能修改的只是元组的一级元素，但是一级元素中的内容可以修改。
- 元组的末尾最好加上一个逗号。
- 元组为可迭代对象，所以可以被迭代方法进行迭代处理。
- 元组是有序的。
5.2 元组的处理
1）元组和列表的转换
ls = list(names) # 转换为列表 print(ls) tu = tuple(ls) # 转换为元组 print(tu)
2）切片：和列表一样
3）方法：
- len()
- count()
- index()
5.3 元组常用方法示例代码
# 元组和列表差不多，但是元组一旦创建，便不能再修改(增加、修改、删除)，所以又叫只读列表 # 元组和列表可以互换 list() tuple() # 元组的末尾最好加上一个逗号 names = ("hgzero","wuzhihao","zero","wuzhihao",) (hgzero,) print("元组的切片") print(names[1:3]) print("元组和列表的转换") ls = list(names) print(ls) tu = tuple(ls) print(tu) print("元组只有2个查的方法，一个是count，另一个是index") print(names.count("wuzhihao")) print(names.index("zero")) print("元组为可迭代对象") print("*".join(names)) # 当元组中全部为字符串时，可以用join方法来转换 print("元组是有序的") tu = (111,"alex",(11,22),[(33,44)],True,33,55) print(tu[3][0][0]) print("元组的不能修改只是针对元组的一级元素,但一级元素中的内容可用修改") tu[3][0]="wuzhihao" print(tu)
6. 字典（dict）
6.1 字典类型说明
字典存储为键值对形式，且字典是无序的。
字典的键（key）必须是唯一的
- key必须可哈希，且key必须为不可变数据类型；
- 布尔值可以作为字典的key；
6.2 字典的处理方法
1）获取所有的键&值
- xx_dick.keys() 返回为一个高仿列表；
- xx_dick.values() 返回为一个高仿列表；
- xx_dick.items() 获取字典中所有的键、值，返回为一个个元组，包含在一个高仿列表中；
2）增加&修改&更新
- info['stu4'] = 'hgzero'
- info['stu4']='Tom'
- update({"name": "hgzero", "age": 18})
3）删除
- del info['stu4']
- pop('stu4')
4）查找
- 'stu1' in info
- get()
- info['stu1']
5）其他
- setdefault()
6.3 字典使用示例代码
# 字典存储为 键值对 形式 # 字典dick 是无序的 info = { "stu1": "hg zero", "stu2": "wu zhihao", "stu3": "hao wu", } print("增加：") info['stu4'] = "wuzhihao" print(info) print("字典的扩展：") b = {"A": 1, "B": 2, "C": 3} info.update(b) # 将b字典中的内容扩展到info中 print(info) info.update(k1=123, k2=456, k3=789) # update() 也支持在括号中直接使用=进行键值对赋值，其会自动转换成字典的形式，类似**kwargs print(info) print("删除(两种)：") info.pop("stu4") # pop() 可传入第二个参数(默认值)，表示若没有指定的key，则返回默认值 print(info) del info["stu3"] print(info) print("修改：") info['stu4'] = "Tom" print(info) print("查找(三种)：") print("stu1" in info) # 判断名为stu1的键是否在info字典中 print(info.get("stu2")) # 获取字典中键为stu2的值 print(info.get("stu9")) # 若要获取的键在字典中不存在，则返回None print(info["stu2"]) # 这样获取对应键的值，若字典中不存在则会报错 print("字典中的其他方法：") print(info.values()) # 获取字典中的所有的值 print(info.keys()) # 获取字典中的所有的键 键和值都可用用for循环来打印出来 print(info.items()) # 获取字典中的所有的键和值 info.setdefault("stu7", "Alex") # 设置默认的键值对 print(info) v = dict.fromkeys([1, 2, 3, 4], "hgzero") # 构建一个字典，将第一个参数迭代为key ， 第二个参数为每个key的value print(v)
print("字典的循环：") for key in info: print(key, info[key]) for k, v in info.items(): # 会先把dict字典转换为list列表，数据量大时不用 print(k, v)
7. 集合
7.1 集合类型说明
1）集合的特点
- 子元素不重复：具有天生去重性（将一个列表转换成集合，就自动去重了）；
- 子元素必须可哈希：集合是可变类型，但是不能修改，只能增加或者删除；
- 集合是无序的；
2）注意
- 集合中没有提供 索引、切片、步长 这些功能，且无法使用索引操作；
- 集合可以通过 len() 函数获取长度，也可以通过for循环来取值；
7.2 集合的三种定义方式
a = {3, 6, 4, 7, 8}
s = set([3, 5, 9, 10, 2]) # 可用set()方法来生成集合, 生成了集合 {3,5,9,10,2}
s2 = set("Hello") # 这样会生成包含这个字符串中每个字母的集合
f = frozenset({2, 3, 5, 6, 7}) # 此处定义了一个不可变类型的集合，不可增加或者删除其中的值
7.3 集合的处理方法
1）添加
- add()
- update()
2）删除
- pop()
- remove()
- discard()
3）拷贝&清空
- copy()
- clear()
4）存在判断
- in
- not in
5）集合中的交、并、差、对称差 集
- |，&，-，^
6）集合关系的判断
- isdisjoint()
- issubset()
- issuperset()
7.4 集合的转换
其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复会自动剔除（自动去重）。
int、str、tuple、dict 都可以转换为集合。
v1 = [11,22,33,11,3,99,22] v2 = set(v1) print(v2) # 结果为：{11,22,33,3,99} v1 = "傻XCCP" v2 = set(v1) print(v2) # 结果为：{"傻","X","C","C","P"} v1 = (11,22,3,11) v2 = set(v1) print(v2) # 结果为：{11,22,3} v1 = {"age":12, "status":True,"name":"傻X"} print( set(v1.keys()) ) # 输出：{'status', 'name', 'age'} print( set(v1.values()) ) # 输出：{'status', 'name', 'age'} print( set(v1.items()) ) # 输出：{('age', 12), ('status', True), ('name', '傻X')}
7.5 集合常用方法示例代码
# 集合：去重性 ， 将一个列表转换成集合，就自动去重了 # 集合是无序的 # 集合是可变类型，但是不能修改，只能增加或者删除 a = {3, 6, 4, 7, 8} # 定义集合的方式 s = set([3, 5, 9, 10, 2]) # 可用set()方法来生成集合, 生成了集合 {3,5,9,10,2} s2 = set("Hello") # 这样会生成包含这个字符串中每个字母的集合 print("定义一个不可变类型的集合:") f = frozenset({2, 3, 5, 6, 7}) # 此处定义了一个不可变类型的集合，不可增加或者删除其中的值 print(f) for i in f: print(i) print("添加(两种)：") s.add("x") # 添加一项，且一次只能添加一个值 s.update([12, 45, 77]) # 添加多项，可以传进各种可迭代对象，统一迭代添加到集合中 s.update(s2) # 更新 print(s) print("删除(三种)：") s.pop() # 因为集合是无序的，所以pop()是随机删除 s.remove("H") # 删除一项，若不存在会报错 s.discard("e") # 若不存在不会报错 print(s) print("拷贝：") b = a.copy() print(b) print("清空：") a.clear() print(a) print("判断:") print(2 in s) # 判断2是否在s集合中 print(2 not in s) print("获取集合的长度：") print(len(s)) # 获取集合的长度 print("集合中的交、并、差、对称差 集：") # a = s | s2 # 两者之间的并集 x = a.union(s2) # b = s & s2 # 两者之间的交集 y = s.intersection(s2) # c = s - s2 # 差集 （在s中，但不在s2中） z = s.difference(s2) # d = s ^ s2 # 对称差集 （在s或s2中，但不会同时出现在二者中） w = s.symmetric_difference(s2) print("两个集合之间关系的判断：") a1 = {1, 2, 3, 4, 5} a2 = {1, 2, 3, 4, 5, 6, 7, 8} print(a1.isdisjoint(a2)) # 判断两个集合中是否有交集，如果没有则为True，如果有则为False print(a1.issubset(a2)) # 判断a1是否为a2的子集，若是则为真，否则为假 print(a1.issuperset(a2)) # 判断a1是否为a2的父集，若是则为真，否则为假