一、引子：
1、为何数据要分不同的类型：
数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示
2、数据类型：
数字
字符串
列表
元组
字典
集合
布尔
二、整体介绍：
1 、int 数字：1,2,3... 用于计算、运算
2、str 字符串： '老男孩'... 主要是少量的数据的存储
3、bool 布尔：True和False，主要用于判断真假。
4、list 列表：[true，1，‘alex’，{‘name’：'oldboy'},[1,2,3],(2,3,4),{'wusir'}] 列表，js里面叫数组
储存大量的数据，可以放多种数据类型，所以它也叫容器类数据。例如：布尔、数字、字符串、字典、列表、元祖、集合...
5、tuple：元组，也可以放多种数据类型，只读列表，不能进行修改，只限制儿子级别的，元组里面的字典可以改。
比如一些重要文件、信息储存在元组中，只允许别人看，不能被恶意修改。
（true，1，‘alex’，{‘name’：'oldboy'},[1,2,3],(2,3,4),{'wusir'}）
6、dict 字典：可以储存大量的数据，关联型数据。而且字典的查询速度特别快，因为它符合二分查找。
{'name':'oldboy','age':45}
7、set 集合：用户关系型数据的交集、并集、差集、子集... ，可以用于列表的去重。集合中元素都是不重复的。
8、
三、基础数据类型详细介绍
1、int（bit_length()方法，该方法也不常用）
i.bit_length()表示将十进制转换成二进制，所占的最少有效位数
"""
二进制 十进制
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
"""
i=3
print(i.bit_length())
i=4
print(i.bit_length())
执行结果：
2
3
2、bool 布尔值
布尔值就两种：True，False。就是反应条件的正确与否。
真 1 True。
假 0 False。
int转换成布尔：
int --- > bool 0 为False 非零 为True
print(bool(0)) 值为：False
print(bool(1)) 值为：True
布尔值转换成数字：
bool ---> int int(True) 等于1 int(False) 等于 0
print(int(True)) 值为：1
print(int(False))值为：0
str转换成布尔：空字符串是False，非空是true
str ---> bool '' False 非空字符串 True
print(bool('')) 值为False，有空格的不叫False
3、字符串（字符串是有索引的，索引就是它的下标。索引从后往前最后一个是-1）
s = 'python自动化运维21期'
s1 = s[0] #通过索引找到对应的元素
print(s1)
3.1、字符串的索引和切片（切片、步长）
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
s = 'python自动化运维21期'
print(s[6:9]) #自动化
print(s[-1]) #-1
print(s[-2]) #-2
切片：（顾头不顾腚）
s[起始索引：结束索引+1：步长]
print(s[:6]) #python
print(s[:6:2]) #从p开始python间隔一个输出一个pto
print(s[:]) #输出整个字符串 python自动化运维21期
print(s[-1:-6:-1]) #期12维运 注意：倒着取值，必须加反向步长
print(s[8:1:-1]) #化动自noht 注意：倒着取值，必须加反向步长
print(s[-1:-5:-2]) #期2
3.2、字符串常用方法：
* s.capitalize() 首字母大写，其他字母小写
s='oldBOY'
s1=s.capitalize()
print(s1) #Oldboy
*** s.upper() 全部转大写
s2=s.upper()
print(s2) #OLDBOY
*** s.lower() 全部转小写
s3=s.lower()
print(s3) #oldboy
*** s.swapcase() 大小写反转
s4=s.swapcase()
print(s4) #OLDboy
* s.title() 非字母的元素隔开的每个单词首字母大写
s='alex wusir*oldboy3taibai'
s5=s.title()
print(s5) #Alex Wusir*Oldboy3Taibai
* s.center() 居中，长度自己设定，默认填充物是None，填充物就是括号里面的
s='oldboy'
s6=s.center(30)
print(s6) # oldboy
s='oldboy'
s6=s.center(30,'*')
print(s6) #************oldboy************
* s.count 字符串中某个元素的个数
s='olodboy'
s7=s.count('o',0,5) #切片，顾头不顾尾
print(s7) # 2
*** s.startswith() s.endswith() start...end...切片，切片都是顾头不顾尾
s='olodboy'
s8=s.startswith('o')
print(s8) #True
s='olodboy'
s8=s.startswith('O')
print(s8) #False
s9=s.endswith('y')
print(s9) #True
s10=s.startswith('ol')
print(s10) #True
s11=s.startswith('lo',1,5) #切片都是顾头不顾尾
print(s11) #True
*** s.strip() #去除首尾的空格、制表符 、换行符
s=' 自动化测试 ' （ 是制表符，代表4个空格。 是换行符）
print(s) # 自动化测试
s.strip() #不仅仅能去除空格，还可以使用填充物，举例
s='oldboey'
s12=s.strip('oye') #只有首尾包含oye元素就去掉，o,y,e是单独的，没有顺序的，去跟字符串首尾地方去
print(s12) #ldb
name=input('>>>').strip() #以后input要加strip()，为了项目
s=' oldboey '
s13=s.lstrip() #只去除左边空格
s14=s.rstrip() #只去除右边空格
print(s13) #oldboey
print(s14) # oldboey
*** split（str--->list相当于字符串转换成列表，可以设置切割次数，隔开后的数比你设置的元素多1）
s = 'oldboywusiroalex'
l = s.split()
print(l) #['oldboywusiroalex']
s1 = 'oldboy,wusir,alex'
l = s1.split(',')
print(l) #['oldboy', 'wusir', 'alex']
s = 'oldboywusiroalex'
l2 = s.split('o')
print(l2) #['', 'ldb', 'ywusir', 'alex']
s = 'oldboywusiroalex'
s15=s.split('o',1) #设置了切割次数
print(s15) #['', 'ldboywusiroalex']
*** join (list---->str)将list转换成字符串
s='olodboy'
s16='+'.join(s)
print(s16) #o+l+o+d+b+o+y
s=['alex','wusir','taibai']
s17='_'.join(s)
print(s17) #alex_wusir_taibai
*** replace 替换
s='abcd'
s1=s.replace('a','p')
print (s1) #pbcd
*** find & index find通过元素找索引，找不到返回-1；index通过元素找索引，找不到会报错。（比较下用find比较好）
s='abcd'
s1=s.find('d')
s2=s.index('c')
print(s1) #3
print(s2) #2
s='abcd'
s1=s.find('m')
print(s1) #-1
s='abcd'
s1=s.index('m')
print(s1)
报错：
Traceback (most recent call last):
File "H:/MyProject/day02.py", line 220, in <module>
s1=s.index('m')
ValueError: substring not found
*** 格式化输出format(3种用法)
{}相当于%，{}中间不能有空格
第1种：
res='我今年{}岁，我的名字叫{}'.format(18,'alex')
print(res) #我今年18岁，我的名字叫alex
第2种：
res='我今年{0}岁，我的名字叫{1},爱好{2},我依然叫{1}'.format(18,'alex','旅游')
print(res) #我今年18岁，我的名字叫alex,爱好旅游,我依然叫alex
第3种：
res='{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res) #egon 18 male
res='我养了只小宠物{str},它的名字叫{name},今年{age}岁，每天早上都{do}'.format(name='super',age=18,do='唱歌',str='猪')
print(res) #我养了只小宠物猪,它的名字叫super,今年18岁，每天早上都唱歌
###公共方法：列表、元祖、字符串都可以用的方法。len、count
s = 'fdsafsdagsdafjdskahdhjlsadhfkj'
print(len(s)) #30
s = 'fdsadd'
print(s.count('d')) #3
* is系列：isalnum、isalpha、isdigit
name = 'jinxin123'
print(name.isalnum()) #字符串由字母或数字组成 #True
print(name.isalpha()) #字符串只由字母组成 #False
print(name.isdigit()) #字符串只由数字组成 #False
i = '123a'
if i.isdigit():
i = int(i)
else:
print("输入有误...") #输入有误...
name = '123'
print(name.isalnum())
print(name.isdigit())
print(name.isalpha())
结果为：
True
True
False
#!/usr/bin/env python # -*-coding:utf-8-*- #求12356的所有子集 s='12356' def PowerSetsBinary(items): #generate all combination of N items N = len(items) #enumerate the 2**N possible combinations for i in range(2**N): combo = [] for j in range(N): #test jth bit of integer i if(i >> j ) % 2 == 1: combo.append(items[j]) yield combo listson=[] for i in PowerSetsBinary(s): listson.append(i) end_listson=[] # test=[] for j in listson: new_str=','.join(j) # test.append(new_str) if new_str != '': end_listson.append(new_str) print(len(end_listson),end_listson) # print(len(test))
执行结果：
(31, ['1', '2', '1,2', '3', '1,3', '2,3', '1,2,3', '5', '1,5', '2,5', '1,2,5', '3,5', '1,3,5', '2,3,5', '1,2,3,5', '6', '1,6', '2,6', '1,2,6', '3,6', '1,3,6', '2,3,6', '1,2,3,6', '5,6', '1,5,6', '2,5,6', '1,2,5,6', '3,5,6', '1,3,5,6', '2,3,5,6', '1,2,3,5,6'])
4、列表（增（3种 ：append、insert、extend）、删（pop、remove、clear、del）、查、改）
总结：在循环一个列表中，不要对列表进行删除的动作（改变列表元素的个数的动作），会出错。
列表也支持索引查找、切片、步长
li = [111,'alex',222,'wusir']
print(li[1]) # alex
print(li[-1]) # wusir
print(li[:2]) # [111, 'alex']
print(li[:3:2])
值为：
alex
wusir
[111, 'alex']
[111, 222]
##增 append
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
#增
#append 在最后追加
l.append('葫芦')
l.append([1,2,3])
print(l) #['老男孩', 'alex', 'wusir', 'taibai', 'ritian', '葫芦', [1, 2, 3]]
print(l.append('好')) #None 这个是完成追加的动作
## insert插入
l.insert(1,'景nvshen') #按索引位置插入
print(l) #['老男孩', '景nvshen', 'alex', 'wusir', 'taibai', 'ritian']
#迭代着添加 extend
l.extend('alex')
l.extend(['111',222,333])
print(l) #['老男孩', 'alex', 'wusir', 'taibai', 'ritian', 'a', 'l', 'e', 'x', '111', 222, 333]
--------------------------------------------------------------------------------------
#删除
#pop 有返回值 按照索引删除，有返回值，删除谁返回谁，增删查改种唯一一个有返回值的
print(l.pop(0)) #老男孩
print(l) #['alex', 'wusir', 'taibai', 'ritian']
#remove 按元素删除
l.remove('alex')
print(l) #['老男孩', 'wusir', 'taibai', 'ritian']
#clear 清空列表
l.clear()
print(l) #[]
#del 内存级别删除列表
del l
print(l) #报错
#del按索引删除
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
del l[1]
print(l) #['老男孩', 'wusir', 'taibai', 'ritian']
#del切片删除
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
del l[:3]
print(l) #['taibai', 'ritian']
# 改
#按照索引改
print(l[2]) #wusir
l[2] = '武藤兰'
print(l) #['老男孩', 'alex', '武藤兰', 'taibai', 'ritian']
#按照切片去改 （把切片内删除，把想添加元素最小单位添加进去）
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
l[:2] = 'abc'
print(l) #['a', 'b', 'c', 'wusir', 'taibai', 'ritian']
l[1:3] = [111,222,333,444]
print(l) #['a', 111, 222, 333, 444, 'wusir', 'taibai', 'ritian']
# 查（3种）
#按照索引去查询，按照切片去查询，for循环查找
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
for i in l:
print(i)
其他方法：
l1 = [1,2,1,2,1,1,3,4]
# 其他方法：
#count 计数
print(l1.count(1)) #4
#len
print(len(l1)) #8
#通过元素找索引
l1 = [1,2,1,2,1,1,3,4]
print(l1.index(2)) #1 只找第一个出现的位置
#排序
l2 = [3,2,4,6,9,8,7,1]
#sort
l2.sort() #从小到大
print(l2) #[1, 2, 3, 4, 6, 7, 8, 9]
l2.sort(reverse=True) #从大到小排序
print(l2) #[9, 8, 7, 6, 4, 3, 2, 1]
#reverse #反过来输出
l2 = [3,2,4,6,9,8,7,1]
l2.reverse() #[1, 7, 8, 9, 6, 4, 2, 3]
#列表的嵌套
l1 = [1, 2, 'alfdsafex', 'wusir',['oldboy', 'ritian', 10], 'taibai']
#1,将'alex'全部变成大写，放回原处。
l1[2] = 'ALEX'
print(l1[2].upper()) #ALEX
l1[2] = l1[2].upper()
print(l1) #[1, 2, 'ALEX', 'wusir', ['oldboy', 'ritian', 10], 'taibai']
#2.给['oldboy', 'ritian', 99] 追加一个元素‘女神’。 一个方法
l1[-2].append('女财神')
print(l1) #[1, 2, 'ALEX', 'wusir', ['oldboy', 'ritian', 10, '女财神'], 'taibai']
#3，将'ritian'首字母大写，放回原处。
l1[-2][1] = l1[-2][1].capitalize()
print(l1) #[1, 2, 'ALEX', 'wusir', ['oldboy', 'Ritian', 10, '女财神'], 'taibai']
#4，将10通过数字相加，或者字符串相加或者等等，变成'100'
l1 = [1, 2, 'alfdsafex', 'wusir',['oldboy', 'ritian', 10], 'taibai']
l1[-2][-1] = str(l1[-2][-1]) + '0'
print(l1) #[1, 2, 'alfdsafex', 'wusir', ['oldboy', 'ritian', '100'], 'taibai']
List=[1,2,2,2,2,3,3,3,4,4,4,4,'abc'] a = {} for i in List: if List.count(i) >= 1: a[i] = List.count(i) print (a) 执行结果： {1: 1, 2: 4, 3: 3, 4: 4, 'abc': 1}
5、字典（在循环字典时，不要对字典进行删除，不要改变字典的大小）
'''
字典的key是唯一的。key 必须是不可变的数据类型。
key:不可变的数据类型(可哈希)：str，bool，tuple，int。
value：任意数据类型。
数据类型分类：
不可变的数据类型(可哈希)：str，bool，tuple，int
可变的数据类型：dict，list，set。
容器类数据类型：list，tuple，dict，set.
字典：存储数据多，关系型数据，查询速度快（二分查找）。
3.6版本之前，字典是无序的，3.6之后字典是有序的。
'''
#字典的增
dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
#增
# dic['high'] 有则覆盖，无则添加
dic['high'] = 180
dic['name'] = 'ritian'
print(dic) #{'name': 'ritian', 'age': 21, 'hobby': 'girl', 'high': 180}
# dic.setdefault() 有则不变，无则添加
dic.setdefault('high')
dic.setdefault('high',180)
dic.setdefault('name','日天')
print(dic) #{'name': 'taibai', 'age': 21, 'hobby': 'girl', 'high': None}
# 删 pop
dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
print(dic.pop('name')) # 返回值 对应的值 #taibai
dic.pop('name') 字典的删除，通过键删除，删除整个键值对
print(dic.pop('name1','没有此key sb')) #没有此key sb
#clear清空字典里面的内容
print(dic)
dic.clear() # 清空
print(dic) #{}
print(dic.popitem()) #随机删除，返回值 #('hobby', 'girl')
print(dic) #{'name': 'taibai', 'age': 21}
del dic #内存级别的删除
print(dic)
dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
del dic['age'] #根据键删除
print(dic) #{'name': 'taibai', 'hobby': 'girl'}
# 改
dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
dic['name'] = '老男孩'
print(dic) #{'name': '老男孩', 'age': 21, 'hobby': 'girl'}
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic) # 将dic的键值对覆盖添加到dic2中，dic不变。
print(dic) #{'name': 'jin', 'age': 18, 'sex': 'male'}
print(dic2) #{'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}
#查
dic = {"name":"jin","age":18,"sex":"male"}
print(dic['name2']) #报错
print(dic.get('name')) #jin
print(dic.get('name1')) #None
print(dic.get('name1','没有此key，sb')) #没有此key，sb
#keys() values() items()
dic = {"name":"jin","age":18,"sex":"male"}
print(list(dic.keys()))
for i in dic.keys():
print(i)
结果如下：
['name', 'age', 'sex']
name
age
sex
----------------------------------
print(dic.values())
for i in dic.values():
print(i)
执行结果：
dict_values(['jin', 18, 'male'])
jin
18
male
----------------------------------
print(list(dic.items()))
for i in dic.items():
print(i)
执行结果：
[('name', 'jin'), ('age', 18), ('sex', 'male')]
('name', 'jin')
('age', 18)
('sex', 'male')
-----------------------------
#分别赋值
a,b = 1,2
a,b,c = ['alex', 'wusir', 'ritain']
print(a,b,c)
a = 1
b = 5
a,b = b,a
print(a,b)
执行结果：
alex wusir ritain
5 1
for i in dic.items():
print(i)
执行结果：
('name', 'jin')
('age', 18)
('sex', 'male')
for k,v in dic.items():
print(k,v)
执行结果：
name jin
age 18
sex male
dic = {"name":"jin","age":18,"sex":"male"}
print(len(dic)) #3
#fromkeys
dic1 = dict.fromkeys('abc','张三')
dic2= dict.fromkeys([1,2,3],'李四')
print(dic1) #{'a': '张三', 'b': '张三', 'c': '张三'}
print(dic2) #{1: '李四', 2: '李四', 3: '李四'}
dic3 = dict.fromkeys('abc',[])
print(dic3) #{'a': [], 'b': [], 'c': []}
dic3['a'].append('老男孩')
print(dic3) #{'a': ['老男孩'], 'b': ['老男孩'], 'c': ['老男孩']}
#字典的嵌套
dic = {
'name_list':['b哥', '张帝', '人帅', 'kitty'],
'老男孩':{
'name':'老男孩',
'age': 46,
'sex': 'ladyboy',
},
}
#1,['b哥', '张帝', '人帅', 'kitty']追加一个元素，'骑兵'
dic['name_list'].append('骑兵')
print(dic)
#2，将kitty全部变成大写。
l1 = dic['name_list']
print(l1[-1].upper())
l1[-1] = l1[-1].upper()
print(dic)
dic['name_list'][-1] = dic['name_list'][-1].upper()
print(dic)
#3，将老男孩 改成oldboy。
dic['老男孩']['name'] = 'oldboy'
print(dic)
#，将ladyboy首字母大写。
dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
print(dic)
执行结果为：
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
骑兵
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': 'oldboy', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '张帝', '人帅', 'kitty', '骑兵'], '老男孩': {'name': 'oldboy', 'age': 46, 'sex': 'Ladyboy'}}
>>> dicxx = {'a':'001', 'b':'002'}
>>> list(dicxx.keys())[list(dicxx.values()).index("001")]
'a'
6、元祖（只读，不能进行增、删、改，只能进行查）
查使用for循环
tu = (11,2,True,[2,3,4],'alex')
for i in tu:
print(i)
print(tu[1]) #通过索引
print(tu[:3:2]) #切片
print(tu.index(True)) #通过元素找索引
print(tu.count(2)) #元素出现的个数
print(len(tu))
tu[-2].append(666)
print(tu)
执行结果：
11
2
True
[2, 3, 4]
alex
2
(11, True)
2
1
5
(11, 2, True, [2, 3, 4, 666], 'alex')
7、集合
'''
集合：
无序，不重复的数据类型。它里面的元素必须是可哈希的。但是集合本身是不可哈希的。
1：关系测试。交集并集，子集，差集....
2,去重。（列表的去重）
'''
集合的增删查改（增（2种：add和update））
set1 = {1,'alex',False,(1,2,3)}
l1 = [1,1,2,2,3,3,4,5,6,6]
l2 = list(set(l1))
print(l2) #[1, 2, 3, 4, 5, 6]
set1 = {'alex','wusir','ritian','egon','barry'}
#增
set1.add('666')
print(set1) #{'ritian', 'alex', 'barry', 'wusir', 'egon', '666'}
# update
set1.update('abc')
print(set1)
#删（remove、pop、clear、del）
set1 = {'alex','wusir','ritian','egon','barry'}
set1.remove('alex') # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1) #{'wusir', 'barry', 'egon', 'ritian'} 该值是变化的
set1.clear() # 清空集合
print(set1) #set()
del set1 # 删除集合
print(set1)
#----集合：关系测试------
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
#交集 & intersectio
print(set1 & set2) #{4, 5}
print(set1.intersection(set2)) #{4, 5}
#并集 | union
print(set1 | set2) #{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2)) #{1, 2, 3, 4, 5, 6, 7, 8}
#差集 - difference
print(set1 - set2) #{1, 2, 3}
print(set2 - set1) #{8, 6, 7}
print(set1.difference(set2)) #{1, 2, 3}
#反交集 ^ symmetric_difference
print(set1 ^ set2) #{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
------------------------------------
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2) #True
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。 #True
print(set2 > set1) #True
print(set2.issuperset(set1)) #True
--------------------------------------------
不可变集合，让集合变成不可变类型
s = frozenset('barry')
s1 = frozenset({4,5,6,7,8})
print(s,type(s))
print(s1,type(s1))
执行结果：
frozenset({'a', 'y', 'r', 'b'}) <class 'frozenset'>
frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>
8、数据类型的补充
range：数字的列表范围，可定制的数字列表、顾头不顾尾
l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
#1
del l1[1::2]
print(l1) #['alex', 'taibai', '老男孩']
-----------------------------------------------------
#再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错
for i in range(len(l1)):
print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
# # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
# # ['alex', 'taibai', 'barry', '老男孩']
# # ['alex', 'taibai', 'barry', '老男孩']
print(i) # 0 1 2 3
if i % 2 == 1:
del l1[i]
print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
# ['alex', 'taibai', 'barry', '老男孩']
# ['alex', 'taibai', 'barry']
print(i) # 0 1
----------------------------------------------------
#range 可定制的数字列表
for i in range(10):
print(i)
结果：
0
1
2
3
4
5
6
7
8
9
for i in range(1,10):也是顾头不顾尾
print(i)
输出：
1
2
3
4
5
6
7
8
9
for i in range(1,10,2):
print(i)
输出：
1
3
5
7
9
for i in range(10,1,-1):
print(i)
输出：
10
9
8
7
6
5
4
3
2
print(range(10)) #range(0, 10)
l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
for i in range(len(l1)-1,-1,-1):
if i % 2 == 1:
del l1[i]
print(l1) #['alex', 'taibai', '老男孩']
# dict 再循环字典时，不要改变字典的大小。
dic = {'k1':'v1','k2':'v2','k3':'v3','r':666}
l1 = []
for i in dic:
if 'k' in i:
l1.append(i)
print(l1)
结果：['k1', 'k2', 'k3']
for i in l1:
del dic[i]
print(dic) #{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'r': 666}
#tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。
tu1 = (1)
print(tu1,type(tu1))
tu2 = ('alex')
print(tu2,type(tu2))
tu3 = (['alex',1,2])
print(tu3,type(tu3))
结果：
1 <class 'int'>
alex <class 'str'>
['alex', 1, 2] <class 'list'>
9、小数据池
python中有小数据池的概念
int、str只有他们有小数据池的概念，其他的数据类型没有
# int -5 ~256 的相同的数全都指向一个内存地址，节省空间。
# str：s = 'a' * 20 以内都是同一个内存地址
#只要字符串含有非字母元素，那就不是一个内存地址
#深浅copy
#赋值运算，它们共用一个列表
a = [1,2,3]
b = a
a.append(666)
print(a,b)
结果：[1, 2, 3, 666] [1, 2, 3, 666]
#浅copy
l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l1,l2) #[1, 2, 3, 666] [1, 2, 3]
print(id(l1),id(l2)) #5241512 5242512
l1 = [1,2,3,[22,33]]
l2 = l1.copy()
l1[-1].append(666)
print(l1,l2) #[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33, 666]]
print(id(l1[-1]),id(l2[-1])) #3079824 3079824
#对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，
# 指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性
#深copy 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。
import copy
l1 = [1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1,l2)
print(id(l1[-1]),id(l2[-1]))
结果：
[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33]]
41402776 41403736
10、编码二
#对于英文
s = 'laonanhai' 对于字符串来说，表现形式是这个（表现形式就是你能看到的），内部编码是unicode
print(s,type(s))
s1 = b'laonanhai' 对于bytes来说，表现形式是这个，内部编码方式为非unicode（非unicode包括utf-8，gbk，gb2312等等等等，只要不是unicode就行）
print(s1,type(s1))
结果：
laonanhai <class 'str'>
b'laonanhai' <class 'bytes'>
----------------------------------------
#对于中文：
s = '中国'
print(s,type(s))
s1 = b'xe4xb8xadxe5x9bxbd'
print(s1,type(s1))
结果：
中国 <class 'str'>
b'xe4xb8xadxe5x9bxbd' <class 'bytes'>
-----------------------------------------------------
#转化
s = 'laonanhai'
s2 = s.encode('utf-8') #str -->bytes encode 编码
s3 = s.encode('gbk')
print(s2,s3)
结果：b'laonanhai' b'laonanhai'
--------------------------------
s = 'laonanhai'
s2 = s.encode('utf-8') #str -->bytes encode 编码
s3 = s.encode('gbk')
print(s2)
print(s3)
ss = s2.decode('utf-8') # bytes ---> str decode 解码
print(ss)
结果：
b'laonanhai'
b'laonanhai'
laonanhai