一、运算符
in方法
"hello" in "abcdefghijklmnopqrstuvwxyz" "li" in ["gg","li"]
二、基本数据类型
int
a.创建方式
n1=123#根据int类型,创建了一个对象
n2=int(123)#根据int类型,创建了一个对象
#在第一句运行时会调用第二句,第二句在内存创建地址
int特有的功能在
int类
功能1
功能2
功能3
__init__(在类名里加一个括号(int(123)),就执行这个类
的功能就像上面的第二句)
n1=123执行时先执行n1=int(123)在执行n1=int.__init__(123)
init(初始化)(不仅限于int可用)
__init__(self,x,base10)(base10表示创建一个十进制的数)
int(”sdfs”(字符串),base0(2))把这个字符串以二进制换为十进制输出
a2=int(“0b100”,2)
print(a2)
输出结果为4
b.
python中对常用的数做了优化例如n1=123,n2=123,则它们就指向同一个内存
(地址相同)不会分开存(-5~257),就像n1=123,n2=n1,超过范围分开存
?但是如果对n1重新赋值,不会影响n2的值?
查看内存地址id(变量名)
int(整型)
在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,
即-2147483648~2147483647
在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,
即-9223372036854775808~9223372036854775807
在赋值后 输出时如果超出int类型自动转换为long类型,long无长度限制,除非内存占完
str
a.创建
s1="alex" s1=str("alex")
#无参数,创建空字符串
#一个参数,创建普通字符串
bytes和str的字符串和字节的转换
#两个字符串,str(字节类型,编码)将字节转换为字符串
name = "李璐" a1=bytes(name,encoding="utf-8") a2=bytes(name,encoding="gbk") print(a1)#输出字符串编码为utf-8的字节 结果为b'/xe6/x9d/x8e/xe7/x92/x90' print(a2)#输出字符串编码为gbk的字节 结果为b'/xc0/xee/xe8/xb4'
将字节转换为字符串
a3=str(bytes(a1),encoding="utf-8") a4=str(bytes(a2),encoding="gbk") print(a3) print(a4)
一般出现x=str(…)的情况时,要么是创建字符串,要么是转化为字符串str(字节,编码)
一般出现x=bytes(…) #()里可为空 要么是创建字节,要么是转化成字节 bytes(字符串,要编成什么编码类型的字节)
bytes字节类型
b.str特有功能需记得
#s1.strip() #两端去除空格
#s1.startswith() #以..开头
#s1.find() #找子序列 “12” “zz”
#s1.replace()#将字符串的某子序列替换为指定的值
#s1.upper() #变大写
#s1.is… #是…吗
str()#执行str类里的__init__
c.公共功能
索引:s1[0]#取一个元素
切片:s1[0:2]#取多个元素
for,在py3.5里
as=["梨树"] for i in as: print(as
) #在这里会逐个输出汉字在py27里不会输出汉字
会输出乱码或空白,因为在py27里是按字节输出的
name="李璐" for i in name: print(i) print(bytes(i,encoding="utf-8"))
#输出16进制表示的二进制
#bytes可以将字符串转换为字节
name = "李璐" for i in name: print(i) bytes_a=bytes(i, encoding="utf-8") print(bytes_a)#输出每一个字节是16进制 for b in bytes_a: print(b,(bin(b)))#输出一个元素时是10进制 #bin(b)二进制输出b
1、3.5for循环时,循环的每一个元素是”字符” 所以len(”李璐”)的长度为2
2.7for循环时每一个元素为字节
2、字符转字节:bianliangming=bytes(”字符串”,encoding=”utf-8″)
#指定编码类型为utf-8
print(bytes_a)#输出字节列表,默认每一个字节是16进制表示
for b in bytes_a:
print(b)
#循环时默认每一个字节十进制表示
十进制的数转换为二进制 bin(二进制的数字 )
结果
李
b’/xe6/x9d/x8e’
230 0b11100110
157 0b10011101
142 0b10001110
璐
b’/xe7/x92/x90′
231 0b11100111
146 0b10010010
144 0b10010000
utf-8 中文3字节 gbk 中文2字节
name = "李璐" a1=bytes(name,encoding="utf-8") a2=bytes(name,encoding="gbk") print(a1) print(a2)
结果
b’/xe6/x9d/x8e/xe7/x92/x90′
b’/xc0/xee/xe8/xb4′
list
list()#执行list类里的__init__
a、
可变的元素的集合
str->创建字符串,或将其他的转换为字符串
list->创建列表,将其他元素转换成列表
1、创建
li=[11,22,33] li=list()#创建一个空的列表 li=list([11,22,33)]
2、转换
s1="李璐" li=list(s1)#s1可以是可迭代的数据,而且在转换时自动迭代转换为列表 #将循环的每一个元素,当作列表的元素 print(li)
结果: [‘李’, ‘璐’]
dic=("k1",123123,"alex",123) ll=list(dic)#元组转换为列表 print(ll)
dic={"k1":123,"k2":"alex","k3":"buff"} ll=list(dic) print(ll)#只输出key(键),字典默认循环时,循环的就是key li=list(dic.values())#dic.values,获取dic的键的值 print(li) lo=list(dic.items())#dic.items,获取dic的键值对 print(lo)
字符串、字典、元组都可以转换为列表
b、列表的特有功能
#追加
li.append()
#清除
li.clear()
#扩展自己,用另外一个可迭的对象,迭代的扩充到自己内部
li.extend()
li=["aa","ff","aasd"] li.extend("123aaa") print(li) #结果 ['aa', 'ff', 'aasd', '1', '2', '3', 'a', 'a', 'a']
#翻转,(倒置)自己内部的元素
li.reverse()
#向指定位置插入指定元素
#li.insert(1,”X”)
c、公共功能
li=[“ss”,”aaa”]
索引:li[1] 取得的元素的类型就是那个元素的类型
切片:li[1:2] 取得的元素类型是你取元素的变量的类型
例如
li=["ss","aaa"] print(li[1]) 结果 aaa print(li[1:2]) 结果 ['aaa']
所有的功能有两种一种是在原来的基础上改变,还有一种是不在原来基础上改变,生成新的
li=["aaa","fff","zzz0"] li.append("aaasss")#在原来的变量上改变 print(li)
ls=" aaa " lsssss=ls.strip()#不在原来变量上改变,原变量不变,对赋值的变量改变 print(ls) print(lsssss) d、 li=["alex",123,{"k1":"v1","k2":{"vv":("zzz",22,333),"ii":444}}] zz=li[2] aa=zz.get("k2") aal=aa.get("vv") aaa=aal[2] print(li[2]["k2"]["vv"][2]) print(aaa) 元组
a.创建和转换
t=(11,22,33) t=tuple((11,22,33))
b.特有方法
count
index
c.嵌套(元素不可修改)
t=(11,22,33) t=((11,22,33)) t=(11,22,["alex",{"k1":"v1"}])
查找v1 t[2][1][“k1”]
e.元组的特性,不可修改,元素不可修改,但是元素的元素可以修改
t=(11,22,["alex",{"k1":"k2"}]) print(t) t[2].append("sss") print(t) t[2][1].setdefault("k2","v3")#或用update或t[2][1]["k3"]=123 print(t)
结果:
(11, 22, [‘alex’, {‘k1’: ‘k2’}])
(11, 22, [‘alex’, {‘k1’: ‘k2’}, ‘sss’])
(11, 22, [‘alex’, {‘k1’: ‘v2’, ‘k2’: ‘v3’}, ‘sss’])
整理:
一般字符串,执行一个功能,生成一个新内容。原来内容不变
list,tuple,dict,执行一个功能,自身进行变化#一般情况下
字典:
1、创建
a={"k1":123} a=dict(k3=123,k2=456) print(a)
用列表创建字典时不能直接加到字典里需要通过enumerate
le=[11,22,44] # dicte=dict[le] #这个报错 dictea=dict(enumerate(le)) print(dictea) #结果{0: 11, 1: 22, 2: 44}
2、字典的特有功能
keys()
values()
items()
pop()
fromkeys()
a1 = {"keys":1111} aa = a1.fromkeys(["key","keys2"], 123) print(aa)#结果{'key': 123, 'keys2': 123}
n=dict.fromkeys(["k1","k2","k3"],[])#用这个方法创建的字典在对键追加值时,会对所有的键进行追加,因为他们在内存里公用一个[],而不用这个方法创建时就不会出现这个情况,例如下面的哪个例子 print(n) n["k1"].append("s") #append在后面追加一个参数 n["k2"]=456 print(n) n2={"k1":[],"k2":[],"k3":[]} print(n2) n2["k1"].append("s") print(n2)
结果{‘k1’: [], ‘k2’: [], ‘k3’: []}
{‘k1’: [‘s’], ‘k2’: 456, ‘k3’: [‘s’]}
{‘k1’: [], ‘k2’: [], ‘k3’: []}
{‘k1’: [‘s’], ‘k2’: [], ‘k3’: []}
原创文章,作者:奋斗,如若转载,请注明出处:https://blog.ytso.com/12378.html