python-the second week
目录数据类型
数据类型之bool
布尔值：
true 和 false
python中自带布尔值
true：除了下面的
false:0,None,（）,[],{}
布尔值变量的命名：一般以is_开头
is_alive=true #是否存在
数据类型之tuple
元组跟列表相似但是列表不能修改数据列表用的是中括号而元组用的是小括号用‘，’隔开
t1 = (110, 120, 130, 'body')
t2 = (110, 140, 'sex')
print(t1) # 输出完整元组
print(t1[0]) # 输出元组中第一和元素
print(t1[0:3]) # 输出元组中从索引0（包括）到索引3（不包括）结束
print(t1[1:]) # 输出元组从索引1到最后
print(t1*2) # 输出两遍元素
print(t1+t2) # 输出t1和t2元素的集合 重复也输出
print(t1[-1]) #输出从后往前的元素
print(len(t1)) # 输出元素的长度
'''
元素值无法修改但是可以把元组转换成列表更改元素最后再转化成元组
'''
数据类型之set
集合是无序和无索引的集合。在 Python 中，集合用花括号编写。
集合只能用于去重和关系运算。
集合中的数据只能是不可变类型
thisset = {"apple", "banana", "cherry"}
print(thisset)
定义空集合与空字典
{} 默认是字典
set() 定义空集合
.add()添加项目
.update()添加多个项目到集合中
.len可以获取项目个数
.remove()或者discard()可以删除元素
.clear()清楚集合
.del彻底删除集合
.union（）连接多个集合
用户交互
input # 获取用户输入
username = input('输入你的用户名')
password = input( '输入你的密码')
"""
1.先执行input获取用户输入
2.将输入的数据绑定给变量名username
3.以后在程序中就可以使用变量名反复调用用户数据
"""
input 获取的信息会成为字符串
输出内部信息
print
1括号中即可以放数据又可以放变量名，支持多个中间用逗号隔开
2print自带换行
换行符：\r\n \n 斜杠与字母组合到一起会产生特殊的含义
3print也可以切换结束符
print（数据，end='默认是\n'）
python2中
input方法需要用户自己提前指定数据类型 写什么类型就是么类型一致 输入的统一处理成字符串
python2中
print方法有两种使用方式
print 数据值
print(数据值)
格式化输出
提前定义好一些内容，在需要的时候只需要局部修改
在程序中需要占位符：%s %d
info = '%s您好'
'''单个占位符'''
info = '%s您好'
print(info % 'leilei')
print('%s您好' % 'mingming')
print(info % ('lei1',))
print('%s您好' % ('lei2'))
''' 多个占位符'''
info2 ='姓名：%s 年龄：%d 爱好：%s'
print(info2 % ('leilei', 18, 'rap'))
q1 = info2 % ('leilei', 18, 'rap')
print(q1)
print(type(q1))
print('姓名：%s 年龄：%d 爱好：%s' % ('lei1', 16, 'sing'))
'''注意事项:有几个占位符就需要几个数据值'''
'''不同占位符的区别'''
demo1 = '%s您好 您本月的话费是%s 余额是%s' # %s常见数据类型都支持
demo2 = '%d您好 您本月的话费是%d 余额是%d' # %d只支持数字类型
print('%08d'% 123) # 00000123生成8位数
print('%08d'% 1234324324) # 1234324324多了即赋值的数值
基本运算符
+ - * / % // **
n = 10
n += 1 # n = n + 1
n -= 1 # n = n - 1
n *= 1 # n = n * 1
n /= 1 # n = n / 1
n %= 1 # n = n % 1
n //= 1 # n = n // 1
n **= 1 # n = n ** 1
2.比较运算符
< > <= >= ==(等于号) !=(不等于)
常用赋值符
1链式赋值
t1 = '01'
12 = t1
t3 = t2
# t1=t2=t3
2交叉赋值
m = 100
y = 101
方法1：
z = m
m = y
y = z
print(m, y, z)
方法2：
m, y = y, m
print(m, y)
3解压赋值
n_list = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
#低级写法
name1 = n_list[0]
name2 = n_list[1]
name3 = n_list[2]
name4 = n_list[3]
# 正常写法
name1, name2, name3, name4 = n_list
#解压赋值在使用的时候需要保证左边的变量名与右边的数值个数保持一致
#当需要解压的数据个数较多只需要其中几个是可以用
a, *b = n_list
print(a) # zhangsan
print(b) # ['lisi', 'wangwu', 'zhaoliu']
a, c, *b = n_list
print(a)
print(c)
print(b) # ['wangwu', 'zhaoliu']
a, *b, c = n_list
print(a) # zhangsan
print(b) # ['lisi', 'wangwu']
print(c) # zhaoliu
# 当数据值不准备使用的时候 可以使用下划线作为变量名绑定
a, *_, c = n_list
逻辑运算符
and(与) or（或） not（非）
print(1 < 10 and 666) # 666
print(1 < 10 and 2 > 1) # false
print(111 and 222) #222
and连接多个条件成立时结果才成立
or连接多个条件只有一个条件成立则成立
not 非
成员运算符
in判断个体在不在群体内
身份运算符
id()返回一串数字该数字可以看成内存地址
==判断数据值是否相同
垃圾回收机制
1引用计数
name = 'lei' 数据值lei引用计数为1
name1 = name 数据值lei引用计数+1 为2
del name1 数据值引用计数-1 为1
当数据身上计数值为0时就会被垃圾机制当作垃圾回收。
当数据值身上的引用计数不为0时永远不会被垃圾回收机制回收
2标记清楚
为了解决循环引用的不足，python的底层不会单单只用引用计数器，引入了一个机制叫做标记清楚。主要针对循环引用问题。
height1 = [123, 321] # 引用计数为1
height2 = [111, 222] # 引用计数为1
height1.append(height2) #引用计数为2 height1 = [123, 321, 111, 222]
height2.append(height1)#引用计数为2 height1 = [ 111, 222 123, 321]
del height1 # 断开变量名height1与列表的关系
del height2 # 断开变量名height2与列表的关系
当内存达到临界值时，程序会自动停止，然后扫面程序中所有的数据，并且给只产生循环引用的数据打上标志之后一次性清楚。
变为
3分代回收
将第二个链表（可能存在循环引用的链表），维护成3个环状双向的链表：
0代： 0代中对象个数达到700个，扫描一次。
1代： 0代扫描10次，则1代扫描1次。
2代： 1代扫描10次，则2代扫描1次。
垃圾回收机制的频繁运行也会消耗各类资源，用0，1，2代分别对计数进行判断来处理数据价值。
流程控制理论
python流程控制大致可以分为三种：
顺序结构
分支结构
事物执行会根据条件的不同做出不同的执行策略。
循环结构
在编写代码时也会涉及到重复的执行某一段代码，这时就会用到循环控制语句。
流程控制必备知识
1.python中使用代码缩进来表示代码的从属关系。
2并不是所有的代码都可以拥用缩进的子代码
3如果有多行子代码属于同一夫代码，那么这些子代码需要保证相同的缩进量。
4python中针对缩进量没有具体的要求，但是推荐4个空格。
5在某一行代码需要编写子代码时，那么比这一行代码的结尾肯定要冒号。
6相同缩进量的代码彼此之间平起平坐，按照顺序结构一次执行。
分支结构
1.单if分支结构
if 条件
条件成立后才会被执行
i = 5
if i < 10:
print(i)
print(i+1)
print(i+2)
2.if...else...分支结构
if 条件:
条件成立之后执行的子代码
else:
条件不成立执行的子代码
3if...elif...else分支结构
if 条件1：
条件1执行的代码
elif 条件2：
条件1不成立条件2成立
elif 条件3:
条件1和条件2都不成立，条件3成立的子代码
else:
上述条件都不成立 执行的子代码
4if嵌套使用
proof = int(input("输入驾驶员每 100ml 血液酒精的含量："))
if proof < 20:
print("驾驶员不构成酒驾")
else:
if proof < 80:
print("驾驶员已构成酒驾")
else:
print("驾驶员已构成醉驾")
循环结构
反复执行的代码
关键字while主要表达形式如下：
while 条件表达式：
语句
与 if 语句相似，while 循环的条件表达式也无须括号，且表达式末尾必须添加冒号。当条件表达式计算结果为 True 时，执行下一行缩进的语句；若条件表达式计算结果为 False，则跳过该条语句继续向下执行。例如：
n = 10
sum = 0
i = 1
while i <= n:
sum = sum + i
i += 1
print("1 到 %d 之和为：%d" %(n,sum))
1先判断条件是否成立
2如果成立就生成循环体里面的代码
3循环体执行完毕后再次回到条件判断处，判断条件是否成立，如果成立则会执行循环体内的代码。
按照上述的规律，直到条件不成立结束循环体内的代码。
关键字
break # 强制退出
continue # 跳过条件判断处
# continue 和 break 用法
i = 1
while i < 10:
i += 1
if i%2 > 0: # 非双数时跳过输出
continue
print i # 输出双数2、4、6、8、10
i = 1
while 1: # 循环条件为1必定成立
print i # 输出1~10
i += 1
if i > 10: # 当i大于10时跳出循环
break
1.死循环
在编程中，一个无法靠自身的控制终止的循环被称为死循环。
死循环会大量增加cpu的运算。
while 2:
print('11111')
2嵌套及全局标志位
所谓嵌套循环就是一个外循环的主体部分是一个内循环。内循环或外循环可以是任何类型，例如 while 循环或 for 循环。 例如，外部 for 循环可以包含一个 while 循环，反之亦然。外循环可以包含多个内循环。 循环链没有限制。
需要注意：
一个break只对他所在的那一层循环结束，并不会结束整个全部代码。
有while循环，想结束循环就要在每层while里写几个break来终止代码。用break太麻烦也可以用全局标识位，来进行对循环控制。
嵌套
user_age = 18
dl = 1
while 1:
print('开始游戏')
user_cage = input("请输入您猜的年龄")
user_cage = int(user_cage)
if user_cage > user_age:
print("猜大了")
elif user_cage < user_age:
print("猜小了")
else:
print("恭喜你猜对了")
break
全局标志位
定义一个计数器然后通过true和false来控制循环结构的执行和结束。
d1 = 1
while d1:
user = input("输入你的用户名")
password = input("输入你的密码")
if user == '123' and password == '123':
while d1:
c1 = input('请输入是否继续')
if c1 == 'q'
d1 = 0
print('正在执行您的指令:%s' % c1)
else:
print('用户名或密码错误')
流程控制FOR循环方法
for 循环
① 关键子in后面的序列指的是一组值，可能是数字，也可能是字符串。
② 关键字for后面的变量就是依次取序列里的值，每取一次值就执行一次下面的代码块，直到序列里的值全取完。
特别注意：for那行语句最后用“：”结尾，下面的代码块必须缩进！
for循环特点
1擅长于遍历取值
2不需要结束条件，自动结束（比while使用简单）
for循环主要遍历的类型（常见：字符串、列表、元组、字典、集合）
d = [123, 'aaa', 'bbb']
for i in d:
print(i)
注：字典输出的是k键
info = {'name':'zhangsan', 'age':'15'}
for i in info:
print(i)
字符串输出的是单个字符
info = 'aaaaaaa'
for i in info:
print(i)
for循环句法的命名：
1见名之一 eg:名字、性别
2如果遍历出来的数据没有具体含义可以用一些字母代替 eg:i、j、k等
for循环可以跟break和for连用
还可以跟else连用
range方法
range(范围)可以用在for循环中产生多个数字数据
for i in range(100):
print(i) # 即可输出0-99数据
for i in range(10, 20):
print(i) # 即可输出10到19的数据值
for i in range(10, 100, 2):
print(i) # 即可生成10到99的等差数列
python2和python3区别
1.print输出不同，在2中无须用将文本加括号在3中必须加括号
2.Python 2将小数点后面没有任何数字的数字视为整数，这可能会导致在除法期间出现意外结果。例如，如果在Python 2代码中输入表达式：3/2，则评估结果将为1，而不是你所期望的1.5。
这是因为Python 2会假设你希望除法的结果为整数，因此它将计算向下舍入到最接近的整数。为了获得结果1.5，你必须编写3.0 / 2.0来告诉Python，你希望它返回一个浮点数，即在结果中包含小数点后面的数字。
Python 3则会默认将3/2评估为1.5，这对于新程序员来说有更直观的感受。
3.range 在2中range()直接产生一个列表 内部含有多个数值xrange()
其实就是python3里面的range在python3中range()类似于一个工厂 不会占用太多的内存空间 要就生产
range实战案例
网络爬虫
大数据是当代时代热门话题大部分网络爬虫是由python来编写代码的，可以使用python来获取想要的数据。
项目爬取博客圆的页码信息数据
y = 'https://www.cnblogs.com/#p%s'
for i in range(200):
print(y % i)
数据类型内置方法理论
内置方法即是每个数据类型自带的功能
数据类型总类：
1.整型 2.浮点型 3.列表型 4.字典型
5.字符型 6.布尔值 7.元组 8.集合
使用数据类型的内置方法统一采用句点符（.）
如：'rain'. 字符串必备的方法()
name = 'rain'
name. 字符串必备的方法()
整型内置方法与操作
关键字
int()
整型就是整数 ，主要用于计算，没有内置方法
类型转换
int('代转换的数据')
字符串中转换的必须是纯数字，出现其他形式立即报错。
进制数转化
十进制的转化
10进制转2进制（0b）
print(bin(101))
10进制转8进制(0o)
print(oct(101))
10进制转16进制(0x)
print(hex(101))
其他进制转10进制
需要int(进制标识符+进制数) 或者使用 int(“进制数”，进制位数)
浮点型内置方法与操作
1类型转化
关键字
folat()
浮点型类型转换仅可以转换一个小数点的数据，若为多个小数点，那么直接报错。
python自身自身对数字敏感度较低
字符串内置方法与操作
关键字：
str()
类型转换
字符串可转换所有数据值
转换的方法
1.索引取值 ： 单个字符 （支持负数）
2.切片取值：
多个字符 ，支持负数，切片的顺序默认为从左往右
切片取值时，顺序默认从左往右，当第三个参数赋值为-1时，循序变为从右往左打印，若没有给第三个参数赋值则默认为1。取值的时候是遵循顾头不顾尾的原则。
3间隔方向
第三个值为负数则从反方向输出
print(s1[:])# :输出所有
print(s1[::2])# 针对整个字符串，隔一个取一个
print(s1[0:5:1])# hello 默认是1可以不写
print(s1[0:5:2]) # hlo 索引0到5 隔一个取一个
4.统计字符串中字符的个数
.len（）统计字符个数，空格也在统计范围内。
5.移除字符首尾指导的字符
运用字符串用内置的方法消除字符时，所表示的不是改变原始数据，而是产生了新的数据，随后输出来调用改变后的数据
还可以进行左消除或者右消除操作：
即在strip前加l或者r
l即left 即左消除
r即right 即右消除
username = input('username>>>:').strip()
username = username.strip()
if username == 'jason':
print('登录成功')
res = ' jason '
print(len(res))
print(len(res.strip())) # 括号内不写 默认移除首尾的空格
res1 = '$$jason$$'
print(res1.strip('$')) # jason
print(res1.lstrip('$')) # jason$$
print(res1.rstrip('$')) # $$jason
6按照指定的字符切割字符串
若出现连续的特征符号，考虑用切割操作。
使用切割字符串时，默认为从左往右切割，若split前由r时，则为从右往左切割
当需要切割次数时，使用maxsplit ，当后面的数值为多少就是需要切割多少次。
info = 'zhangsan|lisi|wangwu|100|200'
res = info.split('|') # 切割字符串的结果是一个列表
print(res,type(res)) #['zhangsan', 'lisi', 'wangwu', '100', '200']
name1,name2,name3,age1,age2=res#zhangsan\lisi\wangwu分别赋值
print(name1,name2,name3,type(name1))
info1=info.split('|',maxsplit=2)# 从左往右 只切一次
print(info1)
info2= info.rsplit('|',maxsplit=1) # 从右往左 只切一次
print(info2)
7.字符串格式化输出
# 1占位符取值
info='my name is{}'.format('张三')# 等价于%s占位
print(info)
# 2 支持索引取值 并且支持重复使用
info1= 'my name is{0} .age is{1}{0}{1}'.format('zhangsan',18)
print(info1)
# 3可以在花括号中使用变量来批量获取数据值。
info2= 'my name is{name} .age is{age}{name}{age}'.format(name='zhangsan',age=16)
print(info2)
#4常用操作
name='zhangsan'
age=18
print(f'my name is{name} .age is{age}{name}{age}')#在格式化输出前加f方法直接获取上述字符内容并进行填写操作，更加简洁
用字符串替换格式化输出，有四种方式，与前三种相比较，在输出结果前加f操作更加方便快捷
8字符串大小写相关
info ='Hello WoRLd'
print(info.upper())#全部大写
print(info.lower())#全部小写
print(info.title())# 只有第一个字母大写
print(info.capitalize())#把字母变大写其他全部小写
print(info.swapcase())#把大写字母变小写字母，把小写字母变大写
print(info.index('l'))#找到l输出索引
print(info.find('l'))#找到l输出索引
# print(info.index('a'))#找不到报错
# print(info.find('a'))#找不到返回-1
print(info.find('ll'))#找到ll输出索引
9.统计字符串中指定字符出现的次数
# res = 'sdashdjasdwjjkashdjasdjjqwhasjjahdjjwqhdjjkasdhws'
# print(res.count('s'))
# print(res.count('jj'))
相比于循环操作，采用.count（）方法能够更加快捷的找到字符串中所需要的数据
10.判断字符串的开头或者结尾
res = 'back say ha ha ha heiheihei'
print(res.startswith('back')) # True
print(res.startswith('b')) # True
print(res.startswith('s')) # False
print(res.endswith('heiheihei'))# True
### print(res.endswith('hei')) # True
print(res.endswith('h')) # False
采用swith()方法判断字符串的开头或者结尾
swith前为start时是判断开头是否正确 可以是首字母，也可是前面的连续字母
swith前为end 时，则是判断结尾是否正确。可以是尾字母，也可以是最后的连续字母（这里是从左往右）
11.字符串替换
res = 'abcd abcd abcd SB SB SB'
print(res.replace('abcd', 'tony')) # 从左往右全部替换
print(res.replace('abcd', 'tony', 1)) # 从左往右替换指定个数
采用replace（）方法可以将字符串中的代码进行替换（遵循从左往右的原则）
在原数据，替换数据之后填写一个数据值则为替换间隔数（没有填写则默认为0）
12.字符串的拼接
res1 = 'hello'
res2 = 'world'
print(res1 + res2) # 字符串支持加号拼接
print(res1 * 10) # 字符串支持乘号重复
print(''.join(['hello', 'world', 'hahaha'])) # join方法拼接
print('|'.join(['hello', 'world', 'hahaha'])) # join方法拼接
# print('$'.join(['jason', 'say', 666])) # 列表中的数据都必须是字符串类型 报错!!!
字符串的拼接支持+ * 形式的拼接，拼接的结果为没有间隔的数据。
当使用join()方法进行拼接时，join前的单引号中若为|则使用|来将其拼接结果进行分割。若为空则视为没有间隔
列表中的数据都必须是字符串类型否则报错。
13.判断字符串中是否为纯数字
print('123'.isdigit()) # True
print('123a'.isdigit()) # False
print(''.isdigit()) # False
采用isdigit()方法对整型进行判断处理
列表内置方法与操作
1列表类型转化
关键字：
list
类型转换
能够被for循环的数据类型都能转换成列表
print(type(list(数据 )))
方法
l1=['123','123321','4564651','465136']
#1索引取值
print(l1[0],type(l1[0]))
print(l1[-2])
#2切片操作
print(l1[0:3])
#3输出全部数列
print(l1[:])
print(l1[-4:-1])
#间隔数 方向 与字符串讲解一致
print(l1[::2])#间隔
#统计列表中数值的个数
print(len(l1))
l1[1] = 1111
print(l1)
#6列表添加数据值
#6.1：尾部添加数据值
l1.append(12312313213)
print(l1)
l1.append(['jason','jianjian','lili'])
#6.2：任意位置插入数值
l1.insert(0,'aaa')
print(l1)
l1.insert(1,[12,12,13,45])
print(l1)
#6.3扩展列表 合并列表
a1=[11,22,33]
a2=[22,33,44]
print(a1+a2)#[11, 22, 33, 22, 33, 44]
a1.extend(a2)#[11, 22, 33, 22, 33, 44]
print(a1)
for i in a2:
a1.append(i)
print(a1)#[11, 22, 33, 22, 33, 44]
#7删除列表数据
#7.1通过删除关键字
del l1[0]
print(l1)
#7.2使用remove
l1.remove(121)
print(l1)
#7.3pop
l1.pop(3) # 括号内填写索引值
print(l1)
l1.pop()# 默认尾部弹出数据值
print(l1)
res = l1.pop(3)
print(res) # 444
res1 = l1.remove(444)
print(res1) # None
#8.排序
ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
ss.sort() # 默认是升序
print(ss)
ss.sort(reverse=True)
print(ss) # 改为降序
#9.统计列表中某个数据值出现的次数
print(l1.count(111))
#10.颠倒列表顺序
l1.reverse()
print(l1)
字典内置方法与操作
1类型转换
dict()
字段转换一般不使用关键字，而是自己编写代码进行转化
2字典掌握的方法
user = {
'name':'zhangsan',
'age': 18,
'like':['ball','music','xiaoji']
}
print(user['name'])#zhangsan
print(user['aaa'])# zhi接报错
print(user.get('name'))#zhangsan
print(user.get('aaa'))#如果不存在k键就会返回None
print(user.get('aaa','111'))#如果不存在k键就会返回111
#3修改值的数据
user['name']='lisi'#将name的值替换成list
#4新增键值对
user['sex']='boy'#添加{'sex':'boy'}
#5删除数据
del user['name']
a1=user.pop('age')
print(a1)#就会弹出age:18数据值
#6统计字典中键值对的个数
print(len(user))#会输出user的键值个数
#7字典三剑客
#用。keys方法一次性输出所有的键
print(user.keys())#一次性输出字典的所有的键
#用.value一次性输出所有值
print(user.value())#一次性输出所有值
#用。items()方法一次性获取字典中所有的键值对
print(user.items())#一次性获取字典的所有值dict_items([('name', 'zhangsan'), ('age', 18), ('like', ['ball', 'music', 'xiaoji'])])
for k,v in user():
#就等于
for i in user():
k,v=i
#8补充说明
user1={}
print(user1.fromkeys(['name','age','hobby'],(123)))#{'name': 123, 'age': 123, 'hobby': 123}
print(user1.fromkeys(['name','age','hobby'],[])#{'name': [], 'age': [], 'hobby': []}
user1['name'].append('jason')
user1['pwd'].append(10)
user1['hobby'].append('sing')
print(user1)
#{'name': ['jason', 10, 'sing'], 'pwd': ['jason', 10, 'sing'], 'hobby': ['jason', 10, 'sing']}
# 键存在则不修改 结果是键对应的值
print(res) # {'name': [], 'pwd': [], 'hobby': []}
res = user_dict.setdefault('username','tony')
print(user_dict, res)
# jason', 'password': 123, 'hobby': ['read', 'music', 'run']} jason
# 存不存在则新增键值对 结果是新增的值
res = user_dict.setdefault('age',123)
print(user_dict, res)
# jason', 'password': 123, 'hobby': ['read', 'music', 'run'], 'age': 123} 123
元组内置方法与操作
1类型转换
tuple()
支持for循环的数据类型都可以转换为元组
2元组必须掌握的方法
t1 = (11, 22, 33, 44, 55, 66)
print(l1[2])# 1.索引取值
print(l1[2:4])# 2.切片操作
print(l1[0:5:2])# 3.间隔、方向
print(len(t1)) # 6 # 4.统计元组内数据值的个数
print(t1.count(11))# 5.统计元组内某个数据值出现的次数
print(t1.index(22))# 6.统计元组内指定数据值的索引值
# 7.元组内如果只有一个数据值那么逗号不能少
# 8.元组内索引绑定的内存地址不能被修改(注意区分 可变与不可变)
#可变的：列表、集合、字典
#不可变的：数字、字符串、元组
# 9.元组不能新增或删除数据
集合内置方法与操作
set()
集合内数据必须是不可变类型(整型 浮点型 字符串 元组)
集合内数据也是无序的 没有索引的概念1类型转换
去重
去除集合内重复的数据值
l2 = {11, 33, 44, 88, 99}
l1 = set(l2)
l2 = list(l1)
print(l2) # [33, 99, 88, 11, 44]
关系运算
& 共同的部分
- 独有的部分
| 全部的部分（和）
^ 独有部分的和
eg:
l1 = {11, 22, 33, 44, 55, 66}
l2 = {11, 33, 44, 88, 99}
print(l1 & l2) # 两个共同的数字
print(l1 - l2) # l1独有的数字
print(l1 | l2) # 两个共同的数字
print(l1 ^ l2) # 两个各自独有的数字
父级，子集
< 或者 >
可变类型与不可变类型
python的可变和不可变数据类型：
- 可变的：列表、集合、字典（可以进行更改，并且更改后物理地址不会发生改变）
- 不可变的：数字、字符串、元组（不可以进行更改，更改后就是一个新的对象了，物理地址发生了变化）
aa='bbaaabb'
bb=[11,22,33]
aa.strip('b')
print(aa) #bbaaabb
a1= bb.append(44)
print(bb)#[11,22,33,44]
print(a1)#none
#可变类型：数据值改变 内存地址不变
a=[11,22,33]
print(a)
print(id(a))
a.append(22)
print(a)
print(id(a))
#不可变类型：数据值改变 内存地址也改变
a2='aahdasdasdasdaa'
print(a2)
print(id(a2))
a2.strip('aa')
print(a2)
print(id(a2))
字符编码理论
1.字符编码只针对文本数据
2.计算机存储数据的本质是二进制，因为计算机只认识0和1，在和计算机交互的时候，用的是我们能够读懂的语言
3.字符编码的发展史：
一家独大
计算机是美国人发明的，由于计算机值认识0和1，于是定义了字符编码，但是只记录了英文字符与数字之间的对应关系，于是有了ASCII码，内部只记录英文字符和数字之间的对应关系
群雄割据
越来越多国家使用计算机之后，各个国家都开发了属于自己国家的字符编码
中国：GBK编码，内部记录了中文字符，英文字符，和数字之间的对应关系，2bytes起步存储中文
韩国：Euc_kr码，内部记录了韩文字符、英文字符与数字之间的对应关系。
日本：shift_JTS码，内部记录了日文字符、英文字符与数字之间的对应关系。
.万国码：unicode，兼容各个国家的字符。原有的字符全部使用2bytes起步存储。
UTF家族，是针对unicode的优化版本，常用的是utf-8。英文1bytes存储，其它统一3bytes存储字符。
内存使用的是Unicode，硬盘使用utf8。
编码与解码
编码：将人类可以读懂的字符按照指定的编码形式转换成计算机能够读懂的语言(数字)。简记：人类的字符转换成计算机的字符。关键字：encode.
解码：将计算机能够读懂的语言按照指定的编码形式转换为人可以独懂得字符，关键字：decode
字符编码实操
1.针对乱码切换编码即可
2.编码与解码
编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
字符串.encode()
解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
bytes类型数据.decode()
3.python2与python3差异
python2默认的编码是ASCII
1.文件头
# encoding:utf8
2.字符串前面加u
u'你好啊'
python3默认的编码是utf系列(unicode)