python语法学习

1、Python中语句结束不需要以分号结束，变量不需要提前定义。

多个变量赋值：

a = b = c = 1

a, b, c = 1, 2, "john"

可以通过使用del语句删除单个或多个对象的引用。

del a, b, c

2、

a = 'word'
print(a*3)     #字符串乘法
#result wordwordword

字符串乘以一个数字，意思就是将字符串复制这个数字的份数。

3、

+	字符串连接	>>>a + b 'HelloPython'
*	重复输出字符串	>>>a * 2 'HelloHello'
[]	通过索引获取字符串中字符	>>>a[1] 'e'
[ : ]	截取字符串中的一部分	>>>a[1:4] 'ell'
in	成员运算符 - 如果字符串中包含给定的字符返回 True	>>>"H" in a True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	>>>"M" not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	>>>print r'\n' \n >>> print R'\n' \n

a = 'I love python'
print(a[0]) #取字符串第一个元素
#result I
print(a[0:5]) #print(a[:5])取字符串第一个到第五个元素，下标0~4
#result I lov
print(a[-1]) #取字符串最后一个元素
#result n

print(a[0:5:2]) #取字符串第一个到第五个元素中的间隔2个的元素
#result ["I","l","v"]

通过下图就能清楚的理解字符串的切片和索引：

>>> seq[:]                # [seq[0],   seq[1],          ..., seq[-1]    ]
>>> seq[low:]             # [seq[low], seq[low+1],      ..., seq[-1]    ]
>>> seq[:high]            # [seq[0],   seq[1],          ..., seq[high-1]]
>>> seq[low:high]         # [seq[low], seq[low+1],      ..., seq[high-1]]
>>> seq[::stride]         # [seq[0],   seq[stride],     ..., seq[-1]    ]
>>> seq[low::stride]      # [seq[low], seq[low+stride], ..., seq[-1]    ]
>>> seq[:high:stride]     # [seq[0],   seq[stride],     ..., seq[high-1]]
>>> seq[low:high:stride]  # [seq[low], seq[low+stride], ..., seq[high-1]]

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

print "My name is %s and weight is %d kg!" % ('Zara', 21)

4、字符串方法

1）split()方法
a = 'www.baidu.com'
print(a.split('.'))
# result ['www', 'baidu', 'com']
2）repalce()方法
a = 'There is apples'
b = a.replace('is','are')
print(b)

# result There are apples

3）strip()方法
a = '  python is cool    '
print(a.strip())
# result  python is cool

strip()方法返回去除两侧（不包括内部）空格的字符串，也可以指定需要去除的字符，将他们列为参数中即可。

a = 'python is cool'
print(a.strip('l'))
# result  python is coo

4）format()方法

字符串格式化，基本语法是通过 {} 和 : 来代替以前的 % 。

print("{:.2f}".format(3.1415926))   #3.14

a = '{} is my love'.format('Python')
print(a)
# result  Python is my love"{1} {0} {1}".format("hello", "world")  # 设置指定位置

# 'world hello world'

print("网站名：{name}, 地址 {url}".format(name="动图菜菜", url="www.halicaicai.cn"))
 
# 通过字典设置参数
site = {"name": "动图菜菜", "url": "www.halicaicai.cn"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['动图菜菜', 'www.halicaicai.cn']

print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

urls = ['http://www.halicaicai.cn/p{}'.format(number) for number in range(1,3)]

print(urls)

#['http://www.halicaicai.cn/p1', 'http://www.halicaicai.cn/p2']

字符串内建函数

string.capitalize()	把字符串的第一个字符大写
string.center(width)	返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace'
string.encode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
string.endswith(obj, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format()	格式化字符串
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()	如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()	如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()	转换 string 中所有大写字符为小写.
string.lstrip()	截掉 string 左边的空格
string.maketrans(intab, outtab])	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.partition(str)	有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2,  num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) )	类似于 find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string))	类似于 index()，不过是从右边开始.
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)	类似于 partition()函数,不过是从右边开始查找
string.rstrip()	删除 string 字符串末尾的空格.
string.split(str="", num=string.count(str))	以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串
string.splitlines([keepends])	按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj])	在 string 上执行 lstrip()和 rstrip()
string.swapcase()	翻转 string 中的大小写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中
string.upper()	转换 string 中的小写字母为大写
string.zfill(width)	返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

decode("gbk")作用为将gbk编码转为unicode编码；encode("gbk")作用为将unicode编码转为gbk编码

5、Python中定义函数的方法

def 函数名 (参数1，参数2...):

  return '结果'

6、Python的判断语句格式

Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。python 并不支持 switch 语句。

if condition:

  do
else:
  do
# 注意：冒号和缩进不要忘记了
# 再看一下多重条件的格式
if condition:
  do
elif condition:
  do
else:

  do

7、Python的循环语句

#for循环
for item in iterable:
  do
#item表示元素，iterable是集合 
for i in range(1,11):
  print(i)

#其结果为依次输出1到10，切记11是不输出的，range为Python内置函数。for循环只能执行range内两数字相减次数。

#通过序列索引迭代：

fruits = ['banana', 'apple', 'mango']

for index in range(len(fruits)):

  print '当前水果 :', fruits[index]

在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print '%d 等于 %d * %d' % (num,i,j)
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print num, '是一个质数'

使用内置 enumerate 函数进行遍历:

sequence = [12, 34, 34, 23, 45, 76, 89]
for i, j in enumerate(sequence):
  print i,j

0 12
1 34
2 34
3 23
4 45
5 76
6 89

#多个数组同时遍历

 for tittle, address, price, img, name, sex in zip(tittles,addresses,prices,imgs,names,sexs):
        data = {
            'tittle':tittle.get_text().strip(),
            'address':address.get_text().strip(),
            'price':price.get_text(),
            'img':img.get("src"),
            'name':name.get_text(),
            'sex':sex.get("class")
        }
        print(data)

#while循环
while condition:

  do

在 python 中，while … else 在循环条件为 false 时执行 else 语句块：

count = 0

while count < 5:

  print count, " is less than 5"

  count = count + 1

else:

  print count, " is not less than 5"

如果你的 while 循环体中只有一条语句，你可以将该语句与while写在同一行中。

pass是空语句，是为了保持程序结构的完整性。不做任何事情，一般用做占位语句。

def sample(n_samples):
    pass

该处的 pass 便是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。

8、元组的元素不能够修改，只能查看，元组的格式如下。
tuple = (1,2,3)
    集合中的元素是无序的，不可重复的对象，有时，可以通过集合把重复的数据去除掉。
list = ['xiaoming','zhangyun','xiaoming']
set = set(list)
print(set)

# result  {'zhangyun', 'xiaoming'}

9、文件操作

Python中通过open()函数打开文件，语法如下：

open(name[, mode[, buffering]])

    open()函数使用文件名做为唯一的强制参数，然后返回一个文件对象。模式（mode）和缓冲（buffering）是可选参数。在Python的文件操作中，mode参数的输入是有必要的，而buffering使用较少。

f = open('C:/Users/Administrator/Desktop/file.txt','r+')

#f.write('hello world')

print ("文件名为: ", f.name)

content = f.read()

print('内容：', content)

通过f.write()方法和f.read()方法写入和读取数据。

使用close()方法关闭文件。

f.close()

10、类

class Bike:
 compose = ['frame','wheel','pedal']
 def use(self):
  print('you are riding')
my_bike = Bike()
print(my_bike.compose)
my_bike.other = 'basket'
print(my_bike.other)

my_bike.use()

类的继承：

class Bike:
    compose = ['frame','wheel','pedal']
    def __init__(self):
        self.other = 'basket' #定义实例的属性
    def use(self,time):
        print('you ride {}m'.format(time*100))
class Share_bike(Bike):
    def cost(self,hour):
        print('you spent {}'.format(hour*2))
bike = Share_bike()
print(bike.other)        #basket
bike.use(1)                #you ride 100m
bike.cost(2)               #you spent 4

11、Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。 解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 就行了 注意：#coding=utf-8 的 = 号两边不要空格。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
print("你好，世界")

Python3.X 源码文件默认使用utf-8编码，所以可以正常解析中文，无需指定 UTF-8 编码。

12、Python 中的标识符是区分大小写的。 以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。 以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。 Python 可以同一行显示多条语句，方法是用分号 ; 分开。

多行语句

Python语句中一般以新行作为语句的结束符。

但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：

total = item_one + \
        item_two + \
        item_three

语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：

days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，其中三引号可以由多行组成，编写多行文本的快捷语法。当你需要一块HTML或者SQL时，这时当用三引号标记。

paragraph = """这是一个段落。
包含了多个语句"""

13、单行注释采用 # 开头，多行注释使用三个单引号(''')或三个双引号(""")

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号 ,

# 不换行输出
print x,
print y,
print x,y

14、Python有五个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表） #[123, 'john']
• Tuple（元组）#(123, 'john') 元组不能二次赋值，相当于只读列表。
• Dictionary（字典） #tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print dict['one'] # 输出键为'one' 的值

print dict[2] # 输出键为 2 的值

print tinydict # 输出完整的字典 {'dept': 'sales', 'code': 6734, 'name': 'john'}

print tinydict.keys() # 输出所有键 ['dept', 'code', 'name']

print tinydict.values() # 输出所有值 ['sales', 6734, 'john']

使用append()方法来添加列表项：

list.append('Google')

使用 del 语句来删除列表的元素：

del list1[2]

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

列表方法：

1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

list4=[123,["das","aaa"],234]
list4
"aaa" in list4                  #in只能判断一个层次的元素
False
"aaa" in list4[1]           #选中列表中的列表进行判断
True
list4[1][1]
'aaa'

a[:] 是创建 a 的一个副本，这样我们在代码中对 a[:] 进行操作后，就不会改变 a 的值了。而若直接对 a 进行操作，那么 a 的值会收到一些操作的影响。

针对列表无法正常输出汉字的解决方法：

#encoding=utf-8

import json

list_words = [ '你', '我', '他' ]
print( list_words )                                        # 无法正常显示汉字
print( str(list_words).decode( 'string_escape' ) )         # 正常显示汉字

list_words_result = json.dumps( list_words, encoding='UTF-8', ensure_ascii=False )
print( list_words_result )
输出结果为：

['\xe4\xbd\xa0', '\xe6\x88\x91', '\xe4\xbb\x96']
['你', '我', '他']
["你", "我", "他"]

remove 和 del 之间的区别：

>>> a=[1,2,3,5,4,2,6]
>>> a.remove(a[5])
>>> a
[1, 3, 5, 4, 2, 6]
说明 remove 移除的是列表中找到的第一个元素。
>>> a=[1,2,3,5,4,2,6]
>>> del(a[5])
>>> a
[1, 2, 3, 5, 4, 6]
说明 del 删除是按索引来的，索引起始位置为 0。

清空列表中的多项空值：

test = ['a','','b','','c','','']
test = [i for i in test if i != '']
print(test)

输出结果为:['a', 'b', 'c']

# -*- coding: UTF-8 -*-

s = 'abcdefg'
# 返回从起始位置到索引位置 2 处的字符串切片
print(s[:3]) # 输出 'abc'

# 返回从第三个索引位置到结尾的字符串切片
print(s[3:]) # 输出 'defg'

# 字符串逆序输出
print(s[::-1]) # 输出 'gfedcba'

# 输出从开始位置间隔一个字符组成的字符串
print(s[::2]) # 输出 'aceg'
print(range(10)[::2])  # 输出偶数：[0, 2, 4, 6, 8]

# 它们也可以相互结合使用。
# 从索引位置 6 到索引位置 2，逆向间隔一个字符
print(s[6:2:-2]) # 输出'ge'

列表解析 List Comprehensions

表达式：[expression for iter_val in iterable if cond_expr]

•  [expression]：最后执行的结果
•  [for iter_val in iterable]：这个可以是一个多层循环
•  [if cond_expr]：两个for间是不能有判断语句的，判断语句只能在最后；顺序不定，默认是左到右。

讨论下多个 for 循环的执行顺序。

从左到右:

>>> print[(x,y)for x in [1,2]for y in [3,4]]
[(1, 3), (1, 4), (2, 3), (2, 4)]
>>> print[(x,y)for x in [1,2]for y in [3,x]]
[(1, 3), (1, 1), (2, 3), (2, 2)]
>>> 

从右到左:

>>> print[(x,y)for x in [1,y]for y in [3,4]]
[(1, 3), (1, 4), (2, 3), (2, 4)]
>>> 

15、数据类型转换

int(x [,base])	将x转换为一个整数
long(x [,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

16、运算

**	幂 - 返回x的y次幂
//	取整除 - 返回商的整数部分（向下取整）

a=10，b=20

print(a**b)  #10的20次方，100000000000000000000

print(9//2)  # 4

print(-9//2)  # -5

注意：Python2.x 里，整数除整数，只能得出整数。如果要得到小数部分，把其中一个数改成浮点数即可。

>>> 1/2
0
>>> 1.0/2
0.5
>>> 1/float(2)
0.5

17、位运算符

 a 为 60，b 为 13，二进制格式如下：

a = 0011 1100，b = 0000 1101

&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

18、逻辑运算符

假设变量 a 为 10, b为 20:

and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

成员运算符

in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

a = 10，b = 20，list = [1, 2, 3, 4, 5 ]

if ( a in list ):

  print "1 - 变量 a 在给定的列表中 list 中"

else:

  print "1 - 变量 a 不在给定的列表中 list 中"

身份运算符is,is not

is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False,id() 函数用于获取对象内存地址。
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。

Python 里的数值和字符串之类的都是不可变对象，对不可变对象操作的结果都会生成一个新的对象。

凡是不可变对象，在同一个代码块中的对象，只有是值相同的对象，就不会重复创建，而是直接引用已经存在的对象。

直接 = 是引用赋值，引用原来的对象；而 [:] 是重新推导，会生成新的对象。

a=[1,2,3,4,5]
>>> b=a
>>> c=a[:]
>>> id(a)
4410359536
>>> id(b)
4410359536
>>> id(c)
4410358240

19、数学函数

abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

随机数函数

choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

20、ord('b') #98

chr(100) # "d"

将整数转化成二进制字符串:

bin(12345).replace('0b','') 

"{0:b}".format(12345)

21、ASCII对英语字符与二进制位之间的关系，做了统一规定。大写的字母A是65（二进制01000001）。

Unicode是一种所有符号的编码。

UTF-8 （1~4个字节）就是在互联网上使用最广的一种 Unicode 的实现方式。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节。其他实现方式还包括 UTF-16（字符用两个字节或四个字节表示）和 UTF-32（字符用四个字节表示）。

ANSI是默认的编码方式。对于英文文件是ASCII编码，对于简体中文文件是GB2312编码（只针对 Windows 简体中文版，如果是繁体中文版会采用 Big5 码）。

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件