一、运算符

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 inas:print(as

) #在这里会逐个输出汉字在py27里不会输出汉字

会输出乱码或空白，因为在py27里是按字节输出的

name="李璐"

for i inname:print(i)print(bytes(i,encoding="utf-8"))

#输出16进制表示的二进制

#bytes可以将字符串转换为字节

name = "李璐"

for i inname:print(i)

bytes_a=bytes(i, encoding="utf-8")print(bytes_a)#输出每一个字节是16进制

for b inbytes_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]) 结果 aaaprint(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': []}