一、运算符 in “hello” in “asdfashellosdfadfadfa” "li" in ['li','ok'] 二、基本数据类型 int a、创建方式 n1 = 123 #根据int类，创建了一个对象 n2 = int123 #根据int类，创建了一个对象 特有的功能在： int类 功能1 功能1 功能1 ... __init__ 初始化 b、int内部优化 n1 = 123 n2 = n1 n1 = 123 n2 = 123 =====两份内存===== -5~257 这个可以通过修改源码改变，由c语言演变过来的，查源码 n1 = 123 n2 = 123 n1 = 123 n2 = 123 ==》对象的内存地址=id（对象或对象的变量名）这样可以查看内存地址 c、长度限制 用int，超出了范围（根据计算机的不同定义的） 32位的操作系统 -2**31 ~ 2**31-1 64位的操作系统 -2**63 ~ 2**63-1 long bytes：可以将字符转换成字节 str a、创建方式 s1 = "zq" s1 = str("zq") b、特有的功能 #两端去除空格 #s1.strip（） #以...开头 #s1.startwith（） #找子序列 #s1.find（） #将字符串中的某子序列替换成指定的值 #s1.replace（） #变大写 #s1.upper（） #是...吗？ #s1.isalpha（） c、公共功能 索引：只能取一个元素 切片：取多个元素 len： for： 编码、for： name = "李露" for i in name: print (i) bytes_list = bytes(i, encoding='utf-8') print(bytes_list) for b in bytes_list: #字节默认16进制 #输出每一个字节默认16进制 print(b,bin(b)) 1、 3.6版本中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进制的数字） d、 bytes和str的转换 a = "张强" #将字符串转换成字节 b1 = bytes(a, encoding='utf-8') print(b1) b2 = bytes(a,encoding='gbk') print(b2) #将字节转换成字符串 print(str(b1,encoding='utf-8')) print(str(b2,encoding='gbk')) ######### x = str() #创建字符串 #转换成字符串 o = bytes() #创建字节 #转换成字节，字符串，要编程什么编码类型的字节 str() str类__init__ list a、创建和转换 1、创建 可变的元素的“集合”，列表 li = [11,22,33,44] li = list() ------------ str -> 创建字符串，或者将其他的转换成字符串 list -> 创建列表，将其他元素转换成列表 li = ([11,22,33,44]) 2、转换 #iterable可迭代的： for可以循环的 a1 = "张强" #for，字符 ==> iterable li = list(a1) #for循环，将循环的每一个元素，当做列表的元素 print(li) #########字典####### dic = {"k1":"zq","k2":"sdfsdf"}#注意是大括号 l3 = list(dic) print(l3) l4 = list(dic.values()) print(l4) l5 = list(dic.items()) print(l5) #字符串，元组，字典 =》 列表 b、 列表特有功能 li = [11,22,3] #追加 # li.append() #清楚 #li.clear（） #扩展自己，用另外一个可迭代的对象扩充到自己 #str字符串，列表list，字典dic，元组tuple # z = "张强" # li.extend(z) # print(li) #翻转，自己内部元素翻转 #li.reverse() #向指定位置插入指定元素 # li.insert(1,'x') # print(li) c、 公共功能 li = ["zq","fd","gg","rg"] 索引：只能取一个元素 切片：取多个元素 li = ["sdf","sdfe","hdf","sdgx"] print(li[1]) print(li[1:3]) sdfe #索引 ['sdfe', 'hdf'] #切片 本来是什么类型，切片取出来的就是什么类型 for len d、 多层嵌套 li = ['sdf','dff','we','gr'] li = ["zq",12,{"k1":"b1","b2":{"qq":(11,22,33),"ii":741}}] li[2] --> {"k1":"b1","b2":{"qq":(11,22,33),"ii":741}} li[2]['k2'] ==> {"qq":(11,22,33),"ii":741} li[2]['k2']["qq"] --> {11,22,33} 元组tuple a、创建和转换 t = (11,22,33) t = tuple((11,22,33)) t = tuple{[]} #字符串、列表、字典 b、 特有的方法 count index c、 嵌套（元素不可修改） t = (11,22,33) t = (11,22,["zq",{"zq1":"z1"}]) t[2] = ["zq",{"zq1":"z1"}] t[2][1] = {"zq1":"z1"} t[2][1]["zq1"] e、 元组的特性，不可修改，谁不可修改---元组的元素不可修改，元素的元素可以修改 #给字典里面的元素添加新元素，两种方法 dic = {"zq1":"zz"} # dic.update({"zq2":15}) #新添加的元素注意加大括号 # print(dic) dic["zq2"] = 15 print(dic) # t = (11,22,33) t = (11,22,["zq",{"zq1":"z1"}]) # print(t[2]) # print(t[2][1]) # print(t[2][1]["zq1"]) # print(t) # t[2].append("zz") # print(t) t = (11,22,["zq",{"zq1":"z1"}]) t[2][1]["zq2"]=15 print(t) t[2][1].update({"zq3":15}) print(t) #什么时候是自身的变化什么时候产生新的 #一般对于字符串的操作 一般字符串，执行一个功能，生成一个新内容，原来内容不变 list、tuple、dic，执行一个功能，自身进行变化 字典： 1.创建 a = {"z1":8} a = dict() li = [11,22,33] # new_dict = dict(li) #这是不可以的 # new_dict = dict(enumerate(li,10)) new_dict = dict(enumerate(li,1)) print(new_dict) #想要把列表转换过来，只能用enumerate 2.字典的内部功能 dic = {"k1":123,"k2":456,"k3":566} #方法，无@staticmothod，对象.方法 # dic.get() #k1,k2,默认值123 #方法，有@staticmothod，类.方法 # n = dic.fromkeys(['k1','k2','k3'],"123") #fromkeys 的功能就是寻找到字典里面存在的key值，重新给其重新赋值 # n = dict.fromkeys(['k1','k2','k3'],"123") # print(n) n = dict.fromkeys(['k1','k2','k3'],[]) print(n) n['k1'].append('x') print(n)