内容回顾
一、运算符
in
"hello" in "ashdjfhajkldad ajkdadh fla"
"li" in ['li','ok']
二、基本的数据类型
int
n1=123 #根据int类，创建了一个对象
n2=int(123) #根据int类，创建了一个对象
a、特有的功能在
int类
功能1
功能2
功能3
_init_
b、int内部优化
n1=123
n2=n1
n1=123
n2=123
===============两份内存===============
#python内容优化：
-5~257
n1=123
n2=123
else:
n1=123
n2=123
#查看内存地址：id（变量名）
#查看字符串、数组长度：len(字符串、数组）
c、长度限制
用int，超出了范围
32位的机器 -2**31~2**31-1
64位的机器 -2**63~2**63-1
long
a、长度限制
bytes
#将字符转换成字节
1 #py3.5 2 name="李露" 3 for i in name: 4 print(i) 5 print(bytes(i,encoding='utd-8')) 6 #bytes可以将字符串转换字节
#UTF-8编码，一个汉字，3个字节，一个字节8位 01010101
str
a、创建方式
s1="alex"
s1=str('alex')
#无参数，创建空字符串
#一个参数，创建普通字符串
#两个参数，int(字节，编码)
将字符串转换成字节
1 a="李露" 2 #将字符创转换成字节 3 #一个汉字用utf-8编码是3个字节，用gbk编码是2个字节 4 b1=bytes(a,encoding='utf-8') 5 print(b1) 6 b2=bytes(a,encoding='gbk') 7 print(b2)
将字节转换成字符串
1 newa1=str(b1,encoding='utf-8') 2 print(newa1) 3 4 newa2=str(b2,encoding='gbk') 5 print(newa2)
x=str()
#创建字符串
#转换成字符串，字节，编码
m=bytes()
#创建字节
#转换成字符串，字符串，要变成什么编码类型的字节
str()
str类 _init_
b、特有的功能
#两端去空格
#s1.strip()
1 #以。。。开头 2 3 #s1.startwith() 4 5 6 7 #找子序列 "12","h" 8 9 #s1.find() 10 11 12 13 #将字符串中的某子序列替换成指定的值 14 15 #s1.replace() 16 17 18 19 #变大写 20 21 s1.upper() 22 23 24 25 #是什么吗 26 27 #s1.isalpha()
c、公共功能
索引：支取一个元素
切片：取多个元素
len:
len("李露")
3.5==》字符
for
编码：
1 name="李露" 2 for i in name: 3 print(i) 4 bytes_list= bytes(i,encoding='utf-8') 5 for b in byte_list: 6 #字节默认16进制 7 #输出每一个字节默认16进制 8 print(b) 9 print(b,bin(b))
1、3.5 for循环时候，循环的每一个元素是“字符”
2、字符=》字节：
bytes_list = bytes("字符串",encoding='utf-8')
#utf-8->3字节
#gbk->2字节
print(bytes_list) #默认每一个字节都是16进制表示
for b in bytes_list:
print(b) #默认每一个字节都是10进制表示
3、10进制的数字 ==》2进制
len
id
bin（10进制的数字） 接受一个10进制的数，转化成二进制
list
可变元素的“集合”
li=[11,22,33,44]
li=list()
--------------------------------------------
str->创建字符串，或者将其他的转换成字符串
--------------------------------------------
list->创建列表，将其他元素转换成列表
1、创建
li=[11,22,33,44,5]
li=list()
li=list([11,22,33,44,5])
2、转换
字符串，元组，字典==》列表
#字符转成列表
1 s1="李露" 2 #for,字符==》可迭代 3 l1=list(s1) #for循环，将循环的每一个元素，当作列表的元素 4 #["李","露"] 5 print(l1)
#元组转成列表
1 s1="李露" 2 #for, 字符==》可迭代 3 l1=list(s1) #for循环，将循环的每一个元素，当作列表的元素 4 #["李","露"] 5 print(l1) 6 t2=("alex","laonanahai","seven") 7 l2=list(t2) 8 print (l2)
1 #字典转成列表 2 dic=("k1":"alex","k2":"seven") 3 l3=list(dic.items()) 4 print(l3)
list()
list类 _init_
列表的特有功能
#追加
li.append()
#清除
li.clear()
#扩展自己，用另一个可迭代的对象，扩充到自己内部
#str, list, dict, tuple
#s="李露"
li.extend(s)
print(li)
#翻转，自己内部元素翻转
#li.reverse()
#向指定位置插入指定元素
li.insert(1, "X")
3、公共功能
li=["alex","eric","seven",123]
索引：li[2]
切片：li[2:3] 切片时候原来是什么类型，切片之后就是什么类型
for循环
len
d、
li = ["alex", "eric", "seven", 123]
li = ["alex", 123, {"k1":"v1","k2": {"vv": 123, "ii": 456 } } ]
li[2] --> {"k1":"v1","k2": {"vv": 123, "ii": 456 } }
li[2]['k2'] --> {"vv": 123, "ii": 456 }
li[2]['k2']["vv"] --> (11,22,123)
list()
list类 _init_
元组
a、创建和转换
t = (11, 22, 33)
t=tuple((11,22,33))
t=tuple([]) #字符串，列表，字典
b、特有方法
count
index
c、嵌套（元素不可修改）
t=(11, 22, 33)
t=(11, 22, ["alex", {"k1": "v1}]}
t[2][1]['k1']
d、元组的特性，不可修改
元组，儿子不能变
元组，儿子不能变，孙子，...
小题
#给t中的元素，字典加一个元素
#方法一 t=(11, 22, ["alex", {"k1": "v1}]} dic = {'k1': "v1" } dic.update(['k2': 123]) print(dic)
#方法二
t=(11, 22, ["alex", {"k1": "v1}]}
dic['k2'] = 123
print(dic)
整理：
一般字符串，执行一个功能，生成一个新内容，原来内容不变
list, tuple, dic，执行一个功能，自身进行变化
字典：
1、创建
a = {"k1": 123}
#用列表创建字典
1 a=dict() 2 li=[11,22,33] 3 new_dict =dict(enumerate(li)) 4 print(new_dict)
#输出结果
{0: 11, 1: 22, 2: 33}
dic = {'k1':123,"k2":456,"k3":111}
#方法，无@staticmethod，对象，方法 #dic.get() #k1,k1 默认123 #方法，@staticmethod，类，方法 n = dic.fromkeys(['k1','k2','k3'],"alex") print(n)
#输出结果
{'k1': 'alex', 'k2': 'alex', 'k3': 'alex'}
dic = {'k1':123,"k2":456,"k3":111} print(dic) n = dic.fromkeys(['k1','k2','k3'],[]) print(n) n2 = {'k1':[],'k2':[],"k3":[]} print(n2) n2['k1'].append('x') print(n2)
#输出结果
{'k1': 123, 'k2': 456, 'k3': 111}
{'k1': [], 'k2': [], 'k3': []}
{'k1': [], 'k2': [], 'k3': []}
{'k1': ['x'], 'k2': [], 'k3': []}
2、字典内部功能
keys()
clear()
values()
items()
pop()
三、其他
