目录
一、数据结构的基本类型
1.可变数据类型(不可哈希类型):可以在存储id不变的情况下,改变数据类型的值,亦为不可哈希类型,不可哈希,不可作为字典的key
列表(list),字典(dict),集合(set)
不可变数据类型(可哈希类型):并非指数据的值不可变,而是改变数据值的实质是形成列一个新的数据,其存储id是改变的,亦为哈希类型,可哈希,可以作为字典的key
# Python中的真假值含义:1. 数字如果非零,则为真,0为假。 2. 其他对象如果非空,则为真
# 通常意义下的类型分类:1. 数字、序列、3映射。 2. 可变类型和不可变类型
数字(int,float,complex,decimal,fraction),字符(str,bytes),元组(tuple),冻结集合(frozenset),None,bool(True,False)
>>> a=1
>>> id(a)
42283352
>>> a+=1#"a+=1"同"a=a+1",但不会改变其id
>>> id(a)
42283328
>>> a=[1,2]
>>> id(a)
140480671529656
>>> a+=[3]
>>> id(a)
140480671529656
2.测试数据类型的三种方法,推荐第三种
L=[1,2,3]
if type(L) == type([]):
print("L is list")
if type(L) == list:
print("L is list")
if isinstance(L, list):
print("L is list")
3.动态类型
变量名通过引用,指向对象。
Python中的“类型”属于对象,而不是变量,每个对象都包含有头部信息,比如"类型标示符" "引用计数器"等
3.1共享引用及在原处修改:
对于可变对象,要注意尽量不要共享引用!
>>> L=[1]
>>> M=[1]
>>> id(L)
139901251999880
>>> id(M)
139901252003784
>>> L is M
False
#=================================================================
>>> L=M=[1]
>>> id(L)
139901252003336
>>> id(M)
139901252003336
>>> L is M
True
3.2 增强赋值和共享引用:
普通+号会生成新的对象,而增强赋值+=会在原处修改
>>> l=m=[1,2]
>>> id(l)
139901252003784
>>> id(m)
139901252003784
>>> l=l+[3] #普通+号
>>> id(l)
139901252004040
>>> m+=[3] #增强赋值
>>> id(m)
139901252003784
二、数字(number)
整型(int)、浮点型(float)、复数(complex),十六进制(Hexadecimal),十进制(decimal),八进制(octal),二进制(binary),分数(fraction)
1.数字常量及类型转换
整数:1234, -1234, 0, 999999999
浮点数:1.23, 1., 3.14e-10, 4E210, 4.0e+210
八进制,十六进制,二进制:0o177, 0x9ff, 0X9FF, 0b101010
复数:3+4j, 3.0+4.0j, 3J
#类型转换
>>> int(20.1)#浮点转整数
20
>>> float(20)#整数转浮点
20.0
>>> complex(20)#整数转复数
(20+0j)
>>> complex(2.3,2.1)#浮点转复数
(2.3+2.1j)
>>> hex(10)#十进制转十六进制
'0xa'
>>> oct(10)#十进制转八进制
'0o12'
>>> bin(10)#十进制转二进制
'0b1010'
>>> int('0xa',base=16)#十六进制转整数
10
2.数字操作符
>>> 1+2#加
3
>>> 2-1#减
1
>>> 2*3#乘
6
>>> 5/3#除
1.6666666666666667
>>> 5//3#取除后(商)的整数部分
1
>>> 5.0//3#取除后(商)的整数部分,分子是浮点型,则结果也是浮点
1.0
>>> 5**2#幂:5的二次方
25
>>>100**0.5#开方:100的开二次根号
10.0
>>> 5%3#取除后的四舍五入后的整数
2
# 生成器函数发送协议 yield x
# 生成匿名函数 lambda args: expression
# 三元选择表达式 x if y else z
# 逻辑与、逻辑或、逻辑非 x and y, x or y, not x
# 成员对象测试 x in y, x not in y
# 对象实体测试 x is y, x is not y
# 大小比较,集合子集或超集值相等性操作符 x<y, x<=y, x>y, x>=y, x==y, x!=y
# Python中允许连续比较 1 < a < 3
# 位或、位与、位异或 x|y, x&y, x^y
# 位操作:x左移、右移y位 x<<y, x>>y
# 真除法、floor除法:返回不大于真除法结果的整数值、取余、幂运算 +, -, *, /, //, %, **
# 一元减法、识别、按位求补(取反) -x, +x, ~x
# 索引、分片、调用 x[i], x[i:j:k]
3.变量:_
#表达式最后所得的值被赋值给变量_,_ 变量应被用户视为只读变量。
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
4.数学函数
#求和,最大值,最小值,参数需要为可迭代类型
>>> sum(123)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> sum('123')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> sum([1,2,3])
6
>>> max(123)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> max(1,2,3)
3
>>> max("abc")
'c'
>>> min('abc')
#返回数字的绝对值,整数
>>> abs(-10)
10
#返回数字的绝对值,浮点数
>>> type(math.fabs(-10))
<class 'float'>
>>> math.fabs(-10)
10.0
#返回浮点数的四舍五入值:round(x,n)n指四舍五入到小数点后的第几位
>>> round(10.5)
10
>>> round(10.6)
11
>>> round(10.6666,2)
10.67
#返回数字的上入整数,math模块函数
>>> math.ceil(5.1)
6
#返回数字的下舍整数,math模块函数,同内建函数int()
>>> math.floor(4.9)
4
#开平方
>>>math.sqrt(100)
10.0
5.随机函数
#需要使用到random模块
>>> import random
#随机选择
>>> random.choice(range(10))
7
>>> random.choice(range(10))
1
#从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1
#randrange ([start,] stop [,step])
start -- 指定范围内的开始值,包含在范围内。
stop -- 指定范围内的结束值,不包含在范围内。
step -- 指定递增基数。如1为所有数字,2为奇数
>>> random.randrange(1,10)
6
#随机生成一个实数,在(0,1)的范围,不包含1
>>> random.random()
0.7270227894366981
>>> random.random()
0.42049921371667365
#随机生存一个实数,在(x,y)的范围,不包含y
>>> random.uniform(1,3)
2.3586820013397682
>>> random.uniform(1,3)
1.1346213127429607
#shuffle() 方法将序列的所有元素随机排序。不能用于不可变类型
>>> a=[1,2,3,4]
>>> random.shuffle(a)
>>> a
[4, 3, 1, 2]
>>> a
[4, 3, 1, 2]
>>> b=(1,2,3,4)
>>> random.shuffle(b)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\lib\ra
dom.py", line 278, in shuffle
x[i], x[j] = x[j], x[i]
TypeError: 'tuple' object does not support item assignment
6.数字相关模块
import math #数字模式
import decimal #小数模式
from decimal import Decimal #小数模式
from fractions import Fraction #分数模式
import random #随机数模式
Decimal("0.01") + Decimal("0.02") # 返回Decimal("0.03")
decimal.getcontext().prec = 4 # 设置全局精度为4 即小数点后边4位
x = Fraction(4, 6) # 分数类型 4/6
x = Fraction("0.25") # 分数类型 1/4 接收字符串类型的参数
7.整数可以利用bit_length函数测试所占的位数
a = 1; a.bit_length() # 1
a = 1024; a.bit_length() # 11
三、字符串
字符串为不可变类型,可哈希、但是序列类型,可迭代
字符串常量
S = '' # 空字符串
S = "spam’s" # 双引号和单引号相同
S = "s\np\ta\x00m" # 转义字符
S = """spam""" # 三重引号字符串,一般用于函数说明
S = r'\temp' # Raw字符串,不会进行转义,抑制转义
S = b'Spam' # Python3中的字节字符串
S = u'spam' # Python2.6中的Unicode字符串
s1+s2, s1*3, s[i], s[i:j], len(s) # 字符串操作
'a %s parrot' % 'kind' # 字符串格式化表达式
'a {1} {0} parrot'.format('kind', 'red')# 字符串格式化方法
for x in s: print(x) # 字符串迭代,成员关系
[x*2 for x in s] # 字符串列表解析
','.join(['a', 'b', 'c']) # 字符串输出,结果:a,b,c
1.访问字符串的值和表达式
#可迭代
>>> a="a,b,c,d"
>>> for i in a:
... print(i)
...
a
,
b
,
c
,
d
#切片
>>> a[1:2]
','
2.拼接&切片
>>> a="abc"
>>> b="def"
>>> a+b
'abcdef'
>>> a*2
'abcabc'
#拼接
>>> a="wang" "home"
>>> print(a)
wanghome
>>> a="wang"\
... 'home'
>>> print(a)
wanghome
#不可变类型
>>> a='hello world'
>>> a[:6]+"rooby"
'hello rooby'
>>> a
'hello world'
#切片
>>> s='abcdefghijk'
>>> s[1:10:3] #第三个参数表示步长
'beh'
3.转义字符
在需要在字符中使用特殊字符时,python用反斜杠(\)转义字符。如下表:
转义字符 | 描述 |
\ | 续行符 |
\a | 响铃 |
\b | 退格符backspace |
\000 | 空值 |
\n | 换行 |
\v | 纵向制表符 |
\t | 横向制表符 |
\r | 回车 |
\f | 翻页 |
>>> a='abcdefg\nhijklmn'
>>> print(a)
abcdefg
hijklmn
4.原始字符串:r/R
原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。
在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中,所有的字符串都是Unicode字符串,所以不用加u
5.字符串格式化
5.1格式化方式
基于C语言的'print'模型,并且在大多数的现有的语言中使用。
通用结构:%[(name)][flag][width].[precision]typecode
#普通格式化%s
>>> st="我叫 %s 今年 %d 岁!" % ('小明', 10)
>>> print(st)
我叫 小明 今年 10 岁!
#普通格式化%d
>>> s="%d"%(1)
>>> s
'1'
# 对齐方式及填充:
"%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234)
"1234... 1234...1234 ...001234"
#基于字典的格式化方式:
>>> a='%(name1)d%(name2)d'%{'name1':2,'name2':2}
>>> print(a)
22
#vars()函数调用返回一个字典,包含了所有本函数调用时存在的变量
>>> a="%(__name__)s is %(__builtins__)s" % vars()
>>> print(a)
__main__ is <module 'builtins' (built-in)>
#%c
>>> s="%c"%('2.3333')
Traceback (most recent call last):
File "<stdin>