Python学习1

Python学习

Python的对象类型

列表

所有元素放在一对方括号中，元素之间使用逗号分隔，其中的元素可以是
任意类型
[1, 2, 3]，[‘a’, ‘b’, [‘c’, 2]]

字典

所有元素放在一对大括号中，元素之间使用逗号分隔，元素形式为“键:值”
{1:‘food’ ,2:‘taste’, 3:‘import’}

元组

不可变，所有元素放在一对圆括号中，元素之间使用逗号分隔，如果元组中只有一个元素的话，后面的逗号不能省略
(2, -5, 6), (3,)

文件

open是Python内置函数，使用指定的模式打开文件，返回文件对象
f = open(‘data.dat’, ‘rb’)

注意

在Python中，不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量。这一点适用于Python任意类型的对象。
Python属于强类型编程语言，Python解释器会根据赋值或运算来自动推断变量类型。Python还是一种动态类型语言，变量的类型也是可以随时变化的。
字符串和元组属于不可变序列，不能通过下标的方式来修改其中的元素值，试图修改元组中元素的值时会抛出异常。

在Python中，允许多个变量指向同一个值，例如：

然而当为其中一个变量修改值以后，其内存地址将会变化，但这并不影响另一个变量，例如接着上面的代码再继续执行下面的代码：

y=x(类似于值传递)

注意

Python采用基于值的内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只保存一份，多个变量指向同一个值的内存空间首地址，这样可以减少内存空间的占用，提高内存利用率。
Python启动时，会对[-5, 256]区间的整数进行缓存。也就是说，如果多个变量的值相等且介于[-5, 256]区间内，那么这些变量共用同一个值的内存空间。
对于区间[-5, 256]区间之外的整数，同一个程序中或交互模式下同一个语句中的同值不同名变量会共用同一个内存空间，不同程序或交互模式下不同语句不遵守这个约定。

    >>> x = -6
    >>> y = -6
    >>> id(x)==id(y)
    False
    >>> x = -5
    >>> y = -5
    >>> id(x) == id(y)
    True
    >>> x = 255
    >>> y = 255
    >>> id(x) == id(y)
    True
    >>> x = 256
    >>> y = 256
    >>> id(x) == id(y)
    True
    >>> x = 257
    >>> y = 257
    >>> id(x) == id(y)
    False
    >>> x = 3.0
    >>> y = 3.0
    >>> id(x) == id(y)
    False
    >>> x, y = 300000, 300000
    >>> id(x) == id(y)
    True
    >>> x = [666666, 666666]
    >>> y = (666666, 666666)
    >>> id(x[0]) == id(x[1])
    True
    >>> id(y[0]) == id(y[1])
    True
    >>> id(x[0]) == id(y[0])
    False

数字

支持复数类型

    >>> a = 3+4j
    >>> b = 5+6j
    >>> c = a+b
    >>> c
    (8+10j)
    >>> c.real        #查看复数实部
    8.0
    >>> c.imag        #查看复数虚部
    10.0
    >>> a.conjugate() #返回共轭复数
    (3-4j)
    >>> a*b           #复数乘法
    (-9+38j)
    >>> a/b           #复数除法
    (0.6393442622950819+0.03278688524590165j)

字符串

用单引号、双引号或三引号界定的符号系列称为字符串。
不可变序列
单引号、双引号、三单引号、三双引号可以互相嵌套，用来表示复杂字符串。
‘abc’、‘123’、‘中国’、“Python”、‘’‘Tom said, “Let’s go”’‘’

• \’ 单引号’
• \” 双引号”

运算

Python中的除法有两种，“/”和“//”分别表示除法和整除运算。

    >>> 3 / 5
    0.6
    >>> 3 // 5
    0
    >>> 3.0 / 5
    0.6
    >>> 3.0 // 5
    0.0
    >>> 13 // 10
    1
    >>> -13 // 10
    -2

关系运算符可以连用，一般用于同类型对象之间值的大小比较，或者测试集合之间的包含关系。

>>> 1 < 3 < 5                       #等价于1 < 3 and 3 < 5
True
>>> 'Hello' > 'world'               #比较字符串大小
False
>>> [1, 2, 3] < [1, 2, 4]           #比较列表大小
True
>>> 'Hello' > 3                     #字符串和数字不能比较
TypeError: unorderable types: str() > int()
>>> {1, 2, 3} < {1, 2, 3, 4}        #测试是否子集
True

成员测试运算符in用于成员测试，即测试一个对象是否为另一个对象的元素。

>>> 3 in [1, 2, 3]       #测试3是否存在于列表[1, 2, 3]中
True
>>> 5 in range(1, 10, 1) #range()是用来生成指定范围数字的内置函数
True
>>> 'abc' in 'abcdefg'   #子字符串测试
True
>>> for i in (3, 5, 7):  #循环，成员遍历
    print(i, end='\t')   #注意，这里打两个回车才会执行

3	5	7	

同一性测试运算符（identity comparison）is用来测试两个对象是否是同一个，如果是则返回True，否则返回False。如果两个对象是同一个，二者具有相同的内存地址。

>>> 3 is 3
True
>>> x = [300, 300, 300]
>>> x[0] is x[1]        #基于值的内存管理，同一个值在内存中只有一份
True
>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x is y              #上面形式创建的x和y不是同一个列表对象
False

集合的交集、并集、对称差集等运算借助于位运算符来实现，而差集则使用减号运算符实现（注意，并集运算符不是加号）。

>>> {1, 2, 3} | {3, 4, 5}         #并集，自动去除重复元素
{1, 2, 3, 4, 5}
>>> {1, 2, 3} & {3, 4, 5}         #交集
{3}
>>> {1, 2, 3} ^ {3, 4, 5}         #对称差集
{1, 2, 4, 5}
>>> {1, 2, 3} - {3, 4, 5}         #差集
{1, 2}

注意

and和or具有惰性求值特点，只计算必须计算的表达式。

>>> 3>5 and a>3          #注意，此时并没有定义变量a
False
>>> 3>5 or a>3           #3>5的值为False，所以需要计算后面表达式
NameError: name 'a' is not defined

Python不支持++和–运算符，只是两个连续的加号和减号。

内置函数

内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制形式，这三个函数都要求参数必须为整数。

>>> bin(555)                      # 把数字转换为二进制串
'0b1000101011'
>>> oct(555)                      # 转换为八进制串
'0o1053'
>>> hex(555)                      # 转换为十六进制串
'0x22b'

内置函数int()用来把实数转换为整数，或把数字字符串按指定进制转换为十进制数。

>>> int(3.5)
3
>>> int(-3.5)
-3
>>> int('101', 2)             # 二进制
5
>>> int('101', 16)            # 十六进制
257
>>> int('x2', 36)             # 36进制
1190
>>> int('\t 8 \n')            # 自动忽略数字两侧的空白字符
8

ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的序数或Unicode码，而chr()则用来返回某序数对应的字符，str()则直接将其任意类型参数转换为字符串。

>>> ord('a')                   >>> chr(65)
97                             'A'

max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他可迭代对象中所有元素最大值、最小值以及所有元素之和，sum()要求元素支持加法运算，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。

>>> import random
>>> a = [random.randint(1,100) for i in range(10)]   #列表推导式
>>> a
[72, 26, 80, 65, 34, 86, 19, 74, 52, 40]
>>> print(max(a), min(a), sum(a))
86 19 548

如果需要计算该列表中的所有元素的平均值，可以直接这样用：

>>>sum(a)/len(a)
54.2

内置函数max()和min()的key参数可以用来指定比较规则。

>>> x = ['21', '1234', '9']
>>> max(x)
'9'
>>> max(x, key=len)
'1234'
>>> max(x, key=int)
'1234'

内置函数sum()的start参数可以实现非数值型列表元素的求和。

>>> sum([1,2,3,4])
10
>>> sum([[1], [2], [3], [4]], [])
[1, 2, 3, 4]

内置函数type()和isinstance()可以判断数据类型。

>>> type([3])                             #查看[3]的类型
<class 'list'>
>>> type({3}) in (list, tuple, dict)      #判断{3}是否为list,tuple
                                          #或dict类型的实例
False
>>> isinstance(3, int)                    #判断3是否为int类型的实例
True
>>> isinstance(3j, (int, float, complex)) #判断3j是否为int,float
                                          #或complex类型
True

sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表。

reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']
>>> reversed(x)                 #逆序，返回reversed对象
<list_reverseiterator object at 0x0000000002E6C3C8>
>>> list(reversed(x))           #reversed对象是可迭代的
['ba', 'b', 'd', 'bc', 'aaaa']

range()语法格式为range([start,] end [, step] )，返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1。

>>> range(5)                  #start默认为0，step默认为1
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1, 10, 2))     #指定起始值和步长
[1, 3, 5, 7, 9]
>>> list(range(9, 0, -2))     #步长为负数时，start应比end大
[9, 7, 5, 3, 1]

enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。

>>> list(enumerate('abcd'))                        #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['Python', 'Great']))          #枚举列表中的元素
[(0, 'Python'), (1, 'Great')]
>>> list(enumerate({'a':97, 'b':98, 'c':99}.items())) #枚举字典中的元素
[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]
>>> for index, value in enumerate(range(10, 15)):  #枚举range对象中的元素
    print((index, value), end=' ')

(0, 10) (1, 11) (2, 12) (3, 13) (4, 14)

内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果。

>>> list(map(str, range(5)))  #把列表中元素转换为字符串
['0', '1', '2', '3', '4']
>>> def add5(v):              #单参数函数
    return v+5

>>> list(map(add5, range(10)))#把单参数函数映射到一个序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> def add(x, y):            #可以接收2个参数的函数
    return x+y

>>> list(map(add, range(5), range(5,10)))
                              #把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]

>>> import random
>>> x = random.randint(1, 1e30)     #生成指定范围内的随机整数
>>> x
839746558215897242220046223150
>>> list(map(int, str(x)))          #提取大整数每位上的数字
[8, 3, 9, 7, 4, 6, 5, 5, 8, 2, 1, 5, 8, 9, 7, 2, 4, 2, 2, 2, 0, 0, 4, 6, 2, 2, 3, 1, 5, 0]

from itertools import chain

xData = [1, 2, 3, 4]
yData = [5, 6, 7, 8]
data = map(lambda x:map(lambda y:(x,y), yData), xData)
#lambda是一个匿名方法
for item in chain(*data):
    print(item, end=' ')

运行结果：
(1, 5) (1, 6) (1, 7) (1, 8) (2, 5) (2, 6) (2, 7) (2, 8) (3, 5) (3, 6) (3, 7) (3, 8) (4, 5) (4, 6) (4, 7) (4, 8)

标准库functools中的函数reduce()可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。

>>> from functools import reduce
>>> seq = list(range(1, 10))
>>> reduce(lambda x, y: x+y, seq)
45

内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。

>>> seq = ['foo', 'x41', '?!', '***']
>>> def func(x):
    return x.isalnum()                  #测试是否为字母或数字

>>> filter(func, seq)                   #返回filter对象
<filter object at 0x000000000305D898>
>>> list(filter(func, seq))             #把filter对象转换为列表
['foo', 'x41']
>>> list(filter(str.isalnum, seq))      #等价的用法
['foo', 'x41']

>>> data = list(range(20))
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> filterObject = filter(lambda x:x%2==1, data)
                                 #过滤，只留下所有奇数
>>> filterObject
<filter object at 0x000001D602B85828>
>>> 3 in filterObject            #3以及3之前的元素都访问过了
True
>>> list(filterObject)           #现在所有元素都访问过了
[5, 7, 9, 11, 13, 15, 17, 19]
>>> list(filterObject)           #filterObject中不再包含任何元素
[]

zip()函数用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，如同拉拉链一样。

>>> list(zip('abcd', [1, 2, 3]))             #压缩字符串和列表
[('a', 1), ('b', 2), ('c', 3)]
>>> list(zip('123', 'abc', ',.!'))           #压缩3个序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]
>>> x = zip('abcd', '1234')
>>> list(x)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]

map、filter、enumerate、zip等对象不仅具有惰性求值的特点，还有另外一个特点：访问过的元素不可再次访问。

Python的基本输入输出

用Python进行程序设计，输入是通过input( )函数来实现的，input( )的一般格式为：

x = input(‘提示：’)

该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。

input()函数的返回结果都是字符串，需要将其转换为相应的类型再处理。

Python 3.x中使用print()函数进行输出。

>>> print(3, 5, 7)
3 5 7
>>> print(3, 5, 7, sep=',')    #指定分隔符
3,5,7
>>> print(3, 5, 7, sep=':')
3:5:7
>>> for i in range(10,20):
    print(i, end=' ')          #不换行

10 11 12 13 14 15 16 17 18 19
的，input( )的一般格式为：

<font color=SalMon>x = input('提示：')</font>

该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。

<font color=SalMon>input()函数的返回结果都是字符串，需要将其转换为相应的类型再处理。</font>

Python 3.x中使用print()函数进行输出。
~~~python
>>> print(3, 5, 7)
3 5 7
>>> print(3, 5, 7, sep=',')    #指定分隔符
3,5,7
>>> print(3, 5, 7, sep=':')
3:5:7
>>> for i in range(10,20):
    print(i, end=' ')          #不换行

10 11 12 13 14 15 16 17 18 19