含义：整型数是不带小数部分的数字。包括自然数、0以及负数。
如：100 0 -5
在Python 3里，只有一种整数类型 ，不分整型和长整型。使用Python的内置函数type可以查看变量所指的数据类型。Python的整数类型与其它语言表示的整数类型不太相同，其它语言整型的取值范围与机器位数有关，例如，在32位机器上，整型的取值范围约是-2^31到2^31，在64位的机器上整型的取值范围约是-2^63到2^63。而Python的整型能表示的数值仅与机器支持的内存大小有关，也就是说Pyhton可以表示很大的数，可以超过机器位数所能表示的数值范围。
10 200 9999999 9999999999999999999999999999
0b111
0b101
0b1111111111
0o177 #127 0o11 #9
0x11 #17 0xFF #255 0x1234ABCD
int(x,base=10) #base代表是几进制,默认是10进制 int(x=0) #用数字或字符串转换为整数，如果不给出参数，则返回0
浮点型数就是带有小数点部分的数字
3.14 3.1 3. 0.14 .14
#小数+e/E+正负号（正号可省略）+指数 6.18E-1 2.9979e8
float(obj) #用字符串或数字转换为浮点数，如果不给出参数则返回0
虚数不能单独存在，它们总是和一个值为0.0的实数部分一起构成一个复数.复数分为两部分，实部（real）+虚部（image），虚部以j或J结尾
1j (2j) 1+1J 3-4J (-100+100J)
complex(r=0.0, i=0.0) #用数字创建一个复数(实部为r, 虚部为i)
用来表示真和假两个状态的类型
True表示真（条件满足或成立）
False表示假（条件不满足或不成立）
bool(x) #用x创建一个布尔值(True/False)
None #空值 False #布尔假值 0 #整型0 0.0 #浮点0 0j #复数0 ‘‘ #空字符串 () #空元组 [] #空列表 {} #空字典 set() #空集合
frozenset() #空固定集合
b‘‘ #空字节串
bytearray(b‘‘) #空字节数组
用来记录文本（文字）信息
在非注释中，凡是用引号括起来的部分都是字符串
引号的种类
‘ 单引号
" 双引号
‘‘‘ 三单引号
""" 三双引号
‘‘ "" ‘‘‘‘‘‘ """"""
‘hello world‘ "hello world" ‘‘‘hello world‘‘‘ """hello world"""
三引号字符串的换行会自动转换为换行符‘\n‘
三引号内可以包含单引号和双引号
#单引号 ‘welcome to beijing\nwelcome to beijing\nI am studing!‘ #双引号 "welcome to beijing\nwelcome to beijing\nI am studing!" #三引号 s=‘‘‘welcome to beijing welcome to beijing! I am studing!‘‘‘
字符串字面值中，用字符反斜杠(\) 后跟一些字符代表一个字符
让转义字符无效
r‘字符串内容‘ r"字符串内容" r‘‘‘字符串内容‘‘‘ r"""字符串内容"""
a=‘C:\newfile\test.py‘ print(a) print(len(a)) #得到字符串的长度 a=r‘C:\newfile\test.py‘ print(a) print(len(a)) #得到字符串的长度
+ += * *=
+ 加号运算符用于字符串的拼接
x = ‘abcd‘ + ‘efg‘ print(x) # abcdefg x += ‘123‘ print(x) # abcdefg123
* 运算符用于生成重复的字符串
x = ‘123‘ y = x * 2 # y = ‘123123‘ x *= 3 # x = ‘123123123‘ x = 3 x *= ‘123‘ # x = ‘123123123‘
> >= < <= == !=
‘A‘ < ‘B‘ # True ‘B‘ < ‘a‘ # True ‘ABC‘ > ‘AB‘ # True ‘AD‘ < ‘ABC‘ # False ‘ABC‘ == ‘abc‘ # False
in 用于序列，字典，集合中，用于判断某个值是否存在于容器中，如果存在则返回True, 否则返回False
对象 in 容器
s = ‘welcome to tarena!‘ ‘to‘ in s # True ‘weimingze‘ in s # False
python 字符串str是不可以改变的字符序列。
字符串[整数表达式]
s = ‘ABCDE‘ print(s[0]) # A print(s[1]) # B print(s[4]) # E
从字符串序列中取出一部分相应的元素重新组成一个字符串
字符串[(开始索引b):(结束索引e)(:(步长s))]注: () 内括起的部分代表可以省略
s = ‘ABCDE‘ a = s[1:4] # a -> ‘BCD‘ a = s[1:] # a -> ‘BCDE‘ a = s[:2] # a -> ‘AB‘ a = s[:] # a -> ‘ABCDE‘ a = s[4:2] # a -> ‘‘ a = s[2:10000] # a -> ‘CDE‘ 开始索引/结束索引可以越界 a = s[::2] # a -> ‘ACE‘ a = s[1::2] # a -> ‘BD‘ a = s[::-1] # a -> ‘EDCBA‘ a = s[::-2] # a -> ‘ECA‘ a = s[4:0:-2] # a -> ‘EC‘
空白字符
是指空格,水平制表符(\t),换行符(\n)等不可见的字符
#将字符串使用sep作为分隔符分割s字符串,返回分割后的字符串的列表, #当不给定参数时,用空白字符作为分隔符进行分割 s.split(sep=None) #连接可迭代对象中的字符串,返回一个中间用s分割的字符串 s.join(iterable)
s = ‘Beijing is capital‘ L = s.split(‘ ‘) # L = [‘Beijing‘, ‘is‘, ‘capital‘] s = ‘\\‘ L = [‘C:‘, ‘Programe files‘, ‘python3‘] s2 = s.join(L) # s2 = b‘C:\Programe files\python3‘
str(obj=‘‘) #将对象转换为字符串
s = 123 print(str(s) + ‘456‘) # 123456
ord(c) #返回一个字符串的Unicode编码值 chr(i) #返回i这个值所对应的字符
print(ord(‘A‘)) # 65 print(ord(‘中‘)) #
hex(i) #将整数转换为十六进制的字符串
oct(i) #将整数转换为八进制字符串
bin(i) #将整数转换为二进制字符串
%
生成想要的格式的字符串
格式字符串中的%为占位符,占位符的位置将用参数值替换
% [格式语法] 类型码
‘%10d‘ % 123 #‘ 123‘ ‘%-10d‘ % 123 #‘123 ‘ ‘%10s‘ % ‘abc‘ #‘ abc‘ ‘%-5s‘ % ‘abc‘ #‘abc ‘ ‘%-5d‘ % 123 #‘00123‘ ‘%7.3f‘ % 3.1415926 #‘003.142‘
python中的序列类型简介（sequence）
1.字符串str
2.列表list
3.元组tuple
4.字节串bytes
5.字节数组bytearray
L=[] #L绑定空列表
L=[1,2,3,4] L=["北京","上海","天津"] L=[1,‘two‘,3,‘四‘] L=[1,2,[3.1,3.2,3.3],4]
#生成一个空的列表，等同于[] list() #用可迭代对象创建一个列表 list(iterable)
L=list() #L为空的列表，等同于[] L=list("ABCD") # L->[‘A‘,‘B‘,‘C‘,‘D‘] L = list(range(1, 10, 2))
+ += * *=
x = [1,2,3] y = [4,5,6] z = x + y # z = [1,2,3,4,5,6]
x = [1,2,3] x += [4,5,6] # x = [1,2,3,4,5,6] x = [1,2,3] x += ‘ABC‘ # += 右侧必须是可迭代对象
x = [1,2,3] * 2 # x = [1,2,3,1,2,3]
x = [1, 2] x *= 3 # x = [1,2,1,2,1,2]
运算符:
< <= > >= == !=
示例:
x = [1,2,3] y = [2,3,4] x != y # True x > [1,2] # True x < y # True [1,3,2] > [1,2,3] # True [‘AB‘, ‘CD‘] > [‘AC‘, ‘BD‘] # False [1, ‘two‘] > [‘two‘, 1] # TypeError
x = [1, ‘Two‘, 3.14, ‘四‘] 1 in x # True 2 in x # False 3 not in x # True ‘四‘ not in x # False
列表[整数表达式]
列表的索引取值与字符串的索引取值规则完全相同
列表的索引为分正向索引和反向索引
L = [‘A‘, 2, ‘B‘, 3] print(L[1]) # 2 x = L[2] # x = ‘B‘
列表是可变的序列，可以通过索引赋值改变列表中的元素
列表[索引] = 表达式
x = [1,2,3,4] x[2] = 3.14 # 改变了第三个元素的值
列表[:]
列表的[::]
列表的切片取值返回一个列表，规则等同于字符串的切片规则
x = list(range(9)) y = x[1:9:2] # y = [1,3,5,7]
列表[切片] = 可迭代对象
切片赋值的赋值运算符的右侧必须是一个可迭代对象
L = [2,3,4] L[0:1] = [1.1, 2.2] print(L) # [1.1, 2.2, 3, 4] L = [2,3,4] L[:] = [7,8] L = [2,3,4] L[1:2] = [3.1, 3.2, 3.3] # [2,3.1, 3.2, 3.3,4] L = [2,3,4] L[1:1] = [2.1, 2.2] # [2, 2.1, 2.2, 3, 4] L = [2,3,4] L[0:0] = [0, 1] # L=[0, 1, 2,3,4] L = [2,3,4] L[3:3] = [5,6] # L=[2,3,4, 5,6] L = [2,3,4] L[1:2] = []
L = list(range(1, 9)) L[1::2] = [2.2, 4.4, 6.6, 8.8] print(L) # [1, 2.2, 3, 4.4, 5, 6.6, 7, 8.8]
对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数
如:
L = [1,2,3,4,5,6] L[::2] = ‘ABCD‘ # 错的 L[::2] = ‘ABC‘ # 对的
del 列表[索引]
del 列表[切片]
L = [1,2,3,4,5,6] del L[0] # L = [2,3,4,5,6] del L[-1] # L = [2,3,4,5] L = [1,2,3,4,5,6] del L[::2] # L = [2, 4, 6]
元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，一但元组生成，则它不可以改变
元组的表示方式:用小括号()括起来，单个元素括起来用逗号(,)区分是单个对象还是元组
t = ()
t = 200, t = (20,) t = (1,2,3) t = 100, 200, 300
t = (20) # t 绑定整数 x, y, z = 100, 200, 300 # 序列赋值 x, y, z = ‘ABC‘ x, y, z = [10, 20, 30]
#生成一个空的元组，等同于() tuple() #用可迭代对象生成一个元组 tuple(iterable)
t = tuple() t = tuple(range(10)) t = tuple(‘hello‘) t = tuple([1,2,3,4])
+ += * *=
用法与列表的用法完全相同
< <= > >= == !=
规则与列表完全相同
规则与列表完全相同
规则与列表完全相同
元组是不可变对象，不支持索引赋值和切片赋值
规则与列表完全相同
元组是不可变对象，不支持索引赋值和切片赋值
#用于获取元组中v所在的索引位置 T.index(v[,begin[,end]]) #用于获取元组中v的个数 T.count(v) #以上方法同list中的index,count方法
for x in reversed("ABCD"): print(x) # D C B A L = [8, 6, 3, 5, 7] L2 = sorted(L) print(L2) # [3, 5, 6, 7, 8] L3 = sorted(L, reversed=True) print(L3) # [8, 7, 6, 5, 3] print(L) # 保持不变
用 {} 括起来，以冒号(:) 分隔键-值对, 各键值对用分号分隔开
d = {}
d = {‘name‘: ‘tarena‘, ‘age‘: 15}
d = {‘姓名‘: ‘小张‘}
d = {1:‘壹‘, 2:‘贰‘}
dict() #创建一个空字典,等同于 {}
dict(iterable) #用可迭代对象初始化一个字典
dict(**kwargs) #关键字传参形式生成一个字典
d = dict() d = dict([(‘name‘, ‘tarena‘), (‘age‘,15)]) d = dict(name=‘tarena‘, age=15)
用[] 运算符可以获取字典内‘键‘所对应的‘值‘
字典[键]
d = dict(name=‘tarena‘, age=15) print(d[‘age‘]) # 15
字典[键] = 表达式
d = {} d[‘name‘] = ‘tarena‘ # 创建一个新的键值对 d[‘age‘] = 15 # 创建键值对 d[‘age‘] = 16 # 修改键值对
del 字典[键]
d = {‘name‘: ‘china‘, ‘pos‘: ‘asia‘}
del d[‘pos‘]
print(d)
del d[‘name‘]
print(d) # {}
可以用 in 运算符来判断一个‘键‘是否存在于字典中,如果存在则返回True, 否则返回False
not in 与 in 返回值相反
d = {‘a‘: 1, ‘b‘: 2}
‘a‘ in d # True
1 in d # False
100 not in d # True
2 not in d # True
字典是可迭代对象，字典只能对键进行迭代访问
d = {‘name‘: ‘tarena‘, (2002, 1, 1): ‘生日‘}
for x in d:
print(x)
s = set() # set() 创建一个空的集合
s = {1, 2, 3} # 集合中的三个整数1,2,3
set() #创建空集合
set(iterable) #用可迭代对象创建一个新的集合对象
s = set("ABC") s = set(‘ABCCBA‘) s = set({1:"一", 2:‘二‘, 5:‘五‘}) s = set([1, 3.14, False]) s = set((2,3,5,7)) # s = set([1, 2, [3.1, 3.2], 4]) # 错的[3.1, 3.2]是可变对象
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 & s2 # s3 = {2, 3}
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 | s2 # s3 = {1,2,3,4}
s1 = {1,2,3}
s2 = {2,3,4}
# 生成属于s1,但不属于s2的所有元素的集合
s3 = s1 - s2
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 ^ s2 # s3 = {1, 4}
# 等同于 s3 = (s1 - s2) | (s2 -s1)
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True 判断子集
s1 > s2 # True 判断超集
s1 = {1, 2, 3}
s2 = {2, 3, 1}
s1 == s2 # True
s1 != s2 # False # 集合的数据没有先后关系
等同于字典，in 运算符用于集合中，当某个值存在于集合中，则为真，否则为假
not in 与 in 返回值相反
s = {1, ‘Two‘, 3.14}
1 in s # True
2 in s # False
3.14 not in s # False
4 not in s # True
固定集合是不可变的，无序的，含有唯一元素的集合
固定集合可以作为字典的键，也可以作为集合的值（元素)
fs = frozenset()
fs = frozenset([2,3,5,7])
frozenset() frozenset(可迭代对象) # 同set函数一致,返回固定集合
运算规则等同于set中的用法
相当于集合的全部方法去掉修改集合的方法
存储以字节为单位的数据
b‘‘ b"" b‘‘‘‘‘‘ b"""""" B‘‘ B"" B‘‘‘‘‘‘ B""""""
b‘ABCD‘ b‘\x41\x42‘ b‘hello tarena‘
bytes() #生成一个空的字节串 等同于 b‘‘ bytes(整型可迭代对象) #用可迭代对象初始化一个字节串 bytes(整数n) #生成n个值为零的字节串 bytes(字符串, encoding=‘utf-8‘) #用字符串的转换编码生成一个字节串
运算规则等同于str中的用法
b = b‘abc‘ + b‘123‘ # b=b‘abc123‘ b += b‘ABC‘ # b=b‘abc123ABC‘ b‘ABD‘ > b‘ABC‘ # True b = b‘ABCD‘ 65 in b # True b‘A‘ in b # True
str ------> bytes
b = s.encode(‘utf-8‘)
bytes ------> str
s = b.decode(‘utf-8‘)
可变的字节序列
bytearray() 创建空的字节数组 bytearray(整数) bytearray(整型可迭代对象) bytearray(字符串,encoding=‘utf-8‘) # 以上参数等同于字节串
字节数组支持索引和切片赋值，规则与列表相同
B.clear() #清空字节数组 B.append(n) #追加一个字节(n为0-255的整数) B.remove(value) #删除第一个出现的字节，如果没有出现，则产生ValueError错误 B.reverse() #字节的顺序进行反转 B.decode(encoding=‘utf-8‘) # 解码 B.find(sub[, start[, end]]) #查找
原文：https://www.cnblogs.com/nlkblog/p/11528484.html