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 \n 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\tage:20\taddr:China\t"
print(like.expandtabs(15)) #每次以15个字符位为一单位，直至出现\t ，每一单位中的除了字符串的空白位用空格填充
print("7个基本魔法：join() , split() , find() , strip() , lower() , upper() , replace()")print("\n"*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 字符串的其他内容
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）深拷贝
深拷贝不仅仅拷贝了原始对象自身，也对其包含的值进行拷贝，它会递归的查找对象中包含的其他对象的应用，来完成更深层次拷贝。
深拷贝产生的副本可以随意修改而不需要担心引起原始值的改变。
importcopy
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 ininfo: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 inf: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 ins)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的父集，若是则为真，否则为假
扫一扫
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
