运算符
1、算术运算符
% 取余运算符，返回余数
** 幂运算符
//返回商的整数部分
2、逻辑运算符
and 与运算符 a and b 如果a为False是，表达式为False，如果a为True返回b的布尔值
or 或运算符 a or b ，如果a为True时，表达式为True，如果a为False则返回b的布尔值
not 非运算符，返回当前布尔值的相反值，如果a为False则返回True
逻辑运算符 顺序 not > and >or 真是坑啊
'''
逻辑运算符
and 同真则真
or 同假则假
not 取反
'''
name = "sunqi"
age = 19 '''
1、判断name == "sunqi"——》True继续进行判断
2、判断age == 19 ——》True继续进行判断
3、判断name == "sunq"——》False然后接下来是or操作
4、判断age==18——》False前后都为False则返回布尔值False
'''
a = (name =="sunqi" and age ==19 and name == 'sunq' or age ==18)
print(a)
基本数据类型
一、字符串（str）
#定义：在单引号\双引号\三引号内，由一串字符组成
name='sunqi' #1、按索引取值(正向取+反向取) ：只能取
#2、切片(顾头不顾尾，步长)
#3、长度len
#4、成员运算in和not in
#5、移除空白strip
#6、切分split
#7、循环
基本方法
#1、strip,lstrip,rstrip
#2、lower,upper
#3、startswith,endswith
#4、format的三种方法
#5、split,rsplit
#6、join
#7、replace
#8、isdigit
举个栗子
#strip
name='*sunqi**'
print(name.strip('*'))#“sunqi”
print(name.lstrip('*'))#“sunqi**”
print(name.rstrip('*'))#“*sunqi” #lower,upper
name='sunqi'
print(name.lower())#转换为小写
print(name.upper())#转换为大写 #startswith,endswith
name='sunqi_good'
print(name.endswith('good'))#以xxx结尾
print(name.startswith('sunqi'))#以xxx开头 #format的三种方法
res='{} {} {}'.format('sunqi',18,'male')
res='{0} {1} {2}'.format('sunqi',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='sunqi',age=18) #split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到*目录
print(name.split('/',1)) name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分，没有从左侧开始的方法 #join
tag=' '
print(tag.join(['sunqi','say','hello','world'])) #可迭代对象必须都是字符串 #replace
name='sunqi say :i have one computer,my name is sunqi'
print(name.replace('sunqi','tony',1)) #isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())#判断是否只包含十进制数字，有小数点也不行 #is数字系列
#在python3中
num1=b'' #bytes
num2=u'' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字 #isdigt:bytes,unicode #判断是否只包含十进制数字，有小数点也不行
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False #isdecimal:uncicode 判断是否只含有十进制字符
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False #isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True #三者不能判断浮点数
num5='4.3'
print(num5.isdigit()) #False
print(num5.isdecimal()) #False
print(num5.isnumeric()) #False #is其他 name='sunqi123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成 print(name.isidentifier())#是否首字母是字母
print(name.islower())#是否是小写
print(name.isupper())#是否是大写
print(name.isspace())#是否只由空格组成。
print(name.istitle())#是否是标题，每个单词首字母都要大写
字符串作业：
1、实现整型加法计算器：例如：5+9，5 + 9， 5+9。
x = input(">>:")
v = x.split("+")
sum = 0
for i in v:
sum = int(i.strip()) + sum
print(sum)
2、计算用户输入的内容有多少个十进制数字，有多少个字母。
x = input(">>:")
d_count = 0
l_count = 0
for i in x:
if i.isdecimal():
d_count = d_count + 1
elif i.isalpha():
l_count = l_count + 1
else:
pass
print("十进制数字的个数为：",d_count)
print("字母的个数为：",l_count)
二、列表
列表是实例化list类创建的数据类型
li = list({11,22,33,44})
li_1 = [11,22,33,44]
print("li->",li)
print("li_1->",li_1)
列表元素的嵌套：字符串，数字，列表，还有接下来的元组，字典，……
li_1 = [11,"",[55,66,88,[99,10,"qeqwre"]]]
通过索引查找到列表的元素，也正因此列表是有序的
列表也可以通过元素查找索引值，如果元素不存在就会报错
li = [1,2,3,"sunqi","tony"]
# print(li.index("sun"))
try:
print(li.index("tony"))
print(li.index("suq"))
except Exception as e:
print("未找到") 4
未找到
li_1[0] = 11
li_1[1][1] = "2"
li_1[2][3][1] = 10
可以通过列表的索引对列表的元素进行修改
li_1 = [11,"",[55,66,88,[99,10,"qeqwre"]]]
li_1[2][3][1] = 1011 li_1-> [11, '', [55, 66, 88, [99, 1011, 'qeqwre']]]
列表支持索引切片替换
li_1 = [11,"",[55,66,88,[99,10,"qeqwre"]]]
li_1[0:2] = [99,20] print("li_1->",li_1) li_1-> [99, 20, [55, 66, 88, [99, 10, 'qeqwre']]]
支持切片删除（del）
li_1 = [11,"",[55,66,88,[99,10,"qeqwre"]]]
del li_1[0:2]
print(li_1) [[55, 66, 88, [99, 10, 'qeqwre']]]
列表反转
li_1[ : : -1]
支持成员运算符in，但是in 只能查询一层的而不能查询嵌套的。
做嵌套成员查询时需要指定索引
li_1 = [11,"",[55,66,88,[99,10,"qeqwre"]]]
print(11 in li_1)
print(55 in li_1)
print(55 in li_1[2]) True
False
True
如何将字符串转换成列表？
v= list("abcdefg")
被list转换的对象要求是可迭代的，最简单的理解就是支持for循环的
列表如何转换为字符串？
（1）如果列表为纯字符串列表，则可以使用字符串的 join 方法
"".join(list)
（2）如果列表既含有数字，又含有字符串，则需要手动编写for循环
列表常用方法：
li = [11,22,33,44]
li.append(“55”)追加到最后，返回值为none，直接将传入的参数作为一个整体加入列表
li.clear()清空列表
b = li.copy()浅拷贝只拷贝一层
li.count("")统计规定元素的个数
li.extend(iterable)扩展原来的列表，必须传递可迭代对象的参数li.extend([9898,"不得了"])
li.index("")获取当前值的索引
li.insert(位置，值)指定位置插入指定值
li.pop(0)删除指定的位置的值并返回删除的值，如果不指定位置则是最后一个并返回删除的值
li.remove("")删除指定的值，若有多个则删除第一个，也就是左边优先
li.reverse()反转列表
li.sort()排序：默认从小到大， reverse = True从大到小
三、元组
元组是实例化tuple类创建的数据类型
元组也可以嵌套任意数据类型
元组也是有序的
tu = (11,22,33,[44,55,"77"])
tu = (11,22,33,[44,55,""])
tu[0] = ""
print(tu) 修改元组的第一层元素会报错
TypeError: 'tuple' object does not support item assignment
元组与列表的最大区别是元组是不可修改的
这种不可修改性体现在元组的第一层元素是不可以被修改的。
可以修改第二层前提是第二层元素是可修改的。
四、字典
字典是通过实例化dict类创建的数据类型
字典的存储方式是键值对 的形式：key: value
字典的键可以是数字，字符串，布尔值，但是不允许是列表，和字典
字典的value可以是任意类型的值
dic = {
11:11,
"":"",
True :"adada",
"test":[11,22,33],
}
print(dic)
{11: 11, '': '', True: 'adada', 'test': [11, 22, 33]}
字典是无序的，没有索引值，不能通过索引值访问字典的元素
访问字典元素的方式：
1、for循环遍历字典
dic = {
11:11,
"":"",
True :"adada",
"test":[11,22,33],
}
for i in dic:
print(i)
11
22
True
test#默认循环字典的键
2、dic.keys()
循环输出字典的键
3、dic.values()
循环输出字典值
dic = {
11:11,
"":"",
True :"adada",
"test":[11,22,33],
}
for i in dic.values():
print(i)
4、dic.items()
遍历数值字典的键和值
dic = {
11:11,
"":"",
True :"adada",
"test":[11,22,33],
}
for k,v in dic.items():
print(k,v)
11 11
22 22
True adada
test [11, 22, 33]
5、dic.get("key")
取出指定key的值，如果key不存在，则返回默认值none
dic = {
11:11,
"":"",
True :"adada",
"test":[11,22,33],
}
v = dic.get("")
print(v)
b = dic.get("")
print(b)
22
None
6、删除字典的键值对
（1）pop()删除指定的key，并返回删除的key的value
v = dic.pop("test")
print(v)
[11,22,33]
（2）popitem删除最后一个元素，并返回删除的键和值组成的元组
v = dic.popitem()
print(v) ('test', [11, 22, 33])
（3）dic.setdefault(k,value=None)
设置字典的键值对，如果指定的键已经存在，则返回存在的value，如果不存在，则添加键值对。
a = dic.setdefault("","")
v = dic.setdefault(11,"")
print(a,v)
print(dic)
789 11
{11: 11, '': '', True: 'adada', 'test': [11, 22, 33], '': ''}
（4）dic.update(**kwargs)
更新字典，如果键存在，则替换值，不存在则添加，返回值为none
a = dic.update({"k1":"v1",11:"dhqih"})
print(a)
print(dic)
None
{11: 'dhqih', '': '', True: 'adada', 'test': [11, 22, 33], 'k1': 'v1'}
列表嵌套字典排序
有如下列表，请按照年龄排序（涉及到匿名函数）
l=[
{'name':'sunqi','age':24},
{'name':'tony','age':3},
{'name':'su','age':18},
] l.sort(key=lambda item:item["age"])
五、布尔值
布尔值只有两种
（1）True 在计算机中存为1
（2）False 在计算机中存为0，常见的False类型：空列表，空字典，空字符串，空元组，0，none
可以调用bool()函数进行布尔值的判断
六、集合
集合是通过实例化set类创建的数据类型
集合特点：
（1）集合的每个元素都不相同
（2）集合是无序的
（3）集合的元素必须是不可变的（不能是列表，字典……）
s = {1,3,3,4,(2,3,4)}
print(s)
{1, (2, 3, 4), 3, 4}
集合的元素是无序的
集合方法：
1、set.add()
向集合中添加元素
s = {1,3,3,4,(2,3,4)}
s.add("sunqi")
print(s)
{1, 3, 4, 'sunqi', (2, 3, 4)}
2、set.remove()
删除集合的指定元素，如果元素不存在就会报错
s = {1,3,3,4,(2,3,4)}
s.remove(1)
print(s)
3、set.pop()
删除集合中的随机一个元素并返回删除的元素
s = {"suqni",1,3,3,4,(2,3,4)}
a = s.pop()
print(s)
print(a)
{3, 4, 'suqni', (2, 3, 4)}
1
4、set.clear()
清空集合
5、set.discard()
移除指定的元素，如果元素不存在，do nothing 不会报错
6、union方法
求出两个集合的并集
s1 = {"sunqi",1,3,4,(2,3,4)}
s2 = {"abc",1,3,7,8,(2,3,4)}
a = s1.union(s2)
print(a)
{1, 'sunqi', 3, 4, 'abc', 7, 8, (2, 3, 4)}
7、intersection方法
求出两个集合的交集
s1 = {"sunqi",1,3,4,(2,3,4)}
s2 = {"abc",1,3,7,8,(2,3,4)}
a = s1.intersection(s2)
print(a)
{1, (2, 3, 4), 3}
8、difference方法
找出第一个集合与第二个集合的差集，就是第一个集合减去与第二个集合相同的元素
s1 = {"sunqi",1,3,4,(2,3,4)}
s2 = {"abc",1,3,7,8,(2,3,4)}
a = s1.difference(s2)
s1.difference_update(s2)#得出差集并将差集更新到s1
print(s1)
print(a)
9、symmetric_difference方法
symmetric_difference_update()求补集并更新s1
补集
s1 = {"sunqi",1,3,4,(2,3,4)}
s2 = {"abc",1,3,7,8,(2,3,4)}
b = s1.intersection(s2)
a = s1.symmetric_difference(s2)
c = s1.union(s2)
print("交集",b)
print("补集",a)
print("并集",c)
交集 {1, (2, 3, 4), 3}
补集 {'sunqi', 4, 'abc', 7, 8}
并集 {'sunqi', 1, 3, 4, 'abc', 7, 8, (2, 3, 4)}
10、issubset 和 issuperset 方法
判断子集和父集
s1 = {1,3,(2,3,4)}
s2 = {"abc",1,3,7,8,(2,3,4)}
a = s1.issubset(s2)#s1是s2的子集
b = s1.issuperset(s2)
print(a)#True
print(b)#False
11、isdisjoint方法
判断两个集合是否有交集，有则返回True
数据类型总结