Python基本手册

发布时间：2019-09-26 07:21:27编辑：auto阅读（1942）

    Python基本手册

    关键词： Python

    1. 常见内置函数

    type() #查看类型
    dir() help() len()
    open() #文本文件的输入输出
    range() enumerate() zip() #循环相关
    iter() #循环对象
    map() filter() reduce() #函数对象
    abs(-2) #取绝对值
    round(2.3) #取整
    pow(3,2) #乘方
    cmp(3.1, 3.2) #比较大小
    divmod(9, 7) #返回除法的结果和余数
    max([2, 4, 6, 8]) #求最大值
    min([1, 2, -1, -2]) #求最小值
    sum([-1, 1, 5, 7]) #求和
    int(“10”) #字符转为整数
    float(4) #转为浮点数
    long(“17”) # 转为长整数
    str(3.5) #转为字符串
    complex(2, 5) #返回复数2 + 5i
    ord(“A”) #A对应的ascii码
    chr(65) #ascii码对应的字符
    unichr(65) #数值65对应的unicode字符
    bool(0) #转换为相应的真假值，0相当于False
    btw:”空” 值相当于False：[],(),{},0,None,0.0
    all([True, 2, “wow!”]) #是否所有元素相当于True，全为True则为True
    any([0, “”, False, [], None]) #是否有元素相当于True
    sorted([1, 7, 4]) #序列升序排序
    reversed([1, 5, 3]) #序列降序排序
    list((1, 2, 3)) #tuple转换为表list
    tuple([4, 5, 4]) #list转换为tuple
    dict(a=3, b=”hi”, c=[1,2,3]) #构建字典
    d = dict(a=3, b=”hi”, c=[1,2,3]) #d则为字典，字典的引用方式d[“a”]的值为3
    input(‘input something’) #等待用户输入
    globals() #返回全局变量名，函数名
    locals() #返回局部命名空间

    • 清屏命令
    import os
os.system('cls')

    2. 标准库

    • 正则表达式 re
    • 时间与日期：time，datetime
    • 路径与文件：os.path， glob
    • 文件管理：os， shutil
    • 存储对象：pickle，cPickle
    • 子进程：subprocess
    • 信号：signal
    • 线程同步：threading
    • 进程信息：os
    • 多进程初步：multiprocessing
    • 数学：math
      函数的使用都要加上包名，避免与其他包的函数混用
      math中函数的使用方法：math.sin() #求正弦
      math.cos() #求余弦
      math.asin() #求反正弦
      math.acos() #求反余弦
      math.pi #pi值
      math.sqrt() #开平方
    • 随机数：random
    • 循环器：itertools
    • 数据库：sqlite3

    3. 爬虫

    实例：

    import urllib2
request = urllib2.Request("http://www.baidu.com")
response = urllib2.urlopen(reques)
print response.read()

    urlopen(url, data, timeout)
    其中
    - url为URL
    - data为访问URL时要传送的数据
    - timeout是设置超时时间
    - 返回response对象
    - read方法可以返回获取到的网页内容

    3.1 GET

    GET方式是直接以链接形式访问，链接中包含了所有的参数

    3.2 POST

    POST把提交的数据放置在HTTP包的包体中

    3.3 Headers

    4. 字符串

    • 转义字符：\
    • 多行字符串：
      Python
      ''' one
      two
      three'''

      输出为：’one \n two \n three’
    • 内置函数：
      raw_input() #从键盘上读取一行文本

    5. 模块

    5.1 定义模块

    定义一个函数放在test.py文件中，然后添加一个above_freezing函数，则可创建一个名为test的模块。如：

    def to_celsius(t):
    return(t-32.0) * 5.0 / 9.0

def above_freezing(t):
    return t>0

    5.2 常用的字符串方法

    用法：字符串.方法
    如”good”.capitalize()，输出为’Good’

    • capitalize() #返回字符串的首字母大写副本
    • find(’s’) #返回字符串中首次出现参数s的索引，如果字符串中没有参数s，则返回-1
    • find(’s’,’beg’) #返回字符串中索引beg之后首次出现参数s的索引，如果字符串中索引beg之后没有参数s，则返回-1
    • islower() #测试所有字符是否均为小写形式
    • isupper() #测试所有字符是否均为大写形式
    • lower() #将所有字符转换为小写形式并返回
    • upper() #将所有字符转换为大写形式并返回
    • replace(‘old’, ‘new’) #将字符串中所有子串old替换为new并返回
    • split() #将空格分隔的单词以列表的形式返回
    • split(del) #将del分隔的子串以列表的形式返回
    • strip() #删除字符串两端的空白符并返回
    • strip(’s’) #删除字符串中的s并返回
    • swapcase() #将小写转换为大写，将大写转换为小写
    • startswith(’s’) #判断字符串是否以字符串s开头
    • endswith(’s’) #判断字符串是否以字符串s结尾

    6. 列表list

    在python中，列表list除了正向索引，还可以逆向索引，最后一个索引从-1开始

    >>>a = [0,1,2,3,4]
>>>a[-1]
4
    • 空列表：
      空列表的索引值范围：0，-1
    • 列表可以包含：整数、字符串
    • 列表是可变的，即创建后可以修改。数字、字符串、元组tuple创建后不可变
    • 多个列表相加
    >>>a = [1,2,3,4]
>>>b = a + [5]
[1,2,3,4,5]
    • 列表乘以一个整数
    >>>a = [1,2]
>>>b = a * 2
[1,2,1,2] #复制一遍加进去

    6.1 列表相关的内置函数

    • len(L) #返回列表L中的元素数量
    • max(L) #返回列表L中元素的最大值
    • min(L) #返回列表L中元素的最小值
    • sum(L) #返回列表L中所有值的和

    6.2 列表元素的循环

    >>>a = [1,2,3,4]
>>>for i in a:
>>>    print i
1
2
3
4

    6.3 列表切片

    形式：list[i:j]
    其中包含i处的值，不含j处的值，i可以省略（从头开始时），若从头到尾，则可写为list[:]

    6.4 列表方法

    • L.append(v) #将值v添加到列表L中
    • L.insert(i,v) #将v插入到列表L的索引i处，同时将其后的元素向后移动
    • L.remove(v) #从列表L中移除第一次找到的值v
    • L.reverse() #反转列表L中的值的顺序
    • L.sort() #对列表中的值以升序排序（字符串以字母顺序为准）
    • L.pop() #移除并返回列表L的最后一个元素（该列表不得为空）

    6.5 列表嵌套列表

    • 列表嵌套列表的索引形式：list[i][j]

    6.6 文件读写

    • 读写函数形式：
    f = open("test.txt","r")
f.read() #read()没有参数则表示读取所有数据

    “r” 表示读取
    “w” 表示写入
    “a” 表示追加

    • 利用for循环操作文件
    f = open("test.txt","r")
for i in test:
    print len(i) #将打印出每一行的字符数
    f = open("test.txt","r")
for i in test:
    print len(i.strip()) #将去除字符串收尾两端的空白符（空格、制表符、换行符等），并返回结果

    7. 选择语句

    7.1 布尔逻辑

    • 运算符：

      and，二元运算符
      or，二元运算符
      not

    • 关系运算符
      > 大于
      < 小于

      = 大于等于
      <= 小于等于
      == 等于
      != 不等于

    • 优先级
      算术运算符 > 关系运算符 > 布尔运算符

    7.2 if语句

    >>>if condition:
>>>    block

    >>>if condition:
>>>    block
>>>elif condition:
>>>    bolck
    • 嵌套if语句

    8. 循环

    8.1 计数

    • range() #该函数可以生成一个数字列表
    >>>range(1,5)
[1,2,3,4,5]
>>>range(5,8)
[5,6,7,8]
>>>range(3)
[0,1,2]
    • 给range()函数设置步长
    >>>range(1,10,2)
[1,3,5,7,9]
    • enumerate() #该函数会返回一个由“值对”组成的列表。值对的第一个元素为索引，第二个元素为索引值
    >>>for i in enumerate("abc"):
>>>    print i
(0,'a')
(1,'b')
(2,'c')
    • 不规则列表
      不规则列表，即嵌套列表中，内层的列表可以元素数目不相同
      如:
      a = [[1,2],[3,4,5],[6,7,8,9]]

    8.2 while循环

    >>>while condition:
>>>    block

    8.3 用户输入循环

    >>>text = ""
>>>while text != "quit":
>>>    text = raw_input("Please enter a chemical formula (or 'quit' to exit):")
>>>    if text == "quit":
>>>        print"...exiting program"
>>>    elif text == "H20":
>>>        print"Water"
>>>    elif text == "NH3":
>>>        print "Ammonia"
>>>    elif text == "CH3":
>>>        print "Methane"
>>>    else:
>>>        print "Unknown compound"

    8.4 break 与 continue

    • break #立即退出循环体
    • continue #跳出本次循环，进入下一次迭代

    9. 文件处理

    • 文件模式
      r 只读模式
      w 只写模式、创建新文件（删除同名的任何文件）
      a 附加到现有文件（如果文件不存在则创建一个）
      r+ 读写模式
      b 附加说明某模式用于二进制文件，即rb或wb
      U 通用换行模式，单独使用U或附加到其他读模式

    9.1 读取文件

    • 读取本地文件
    >>>f = open("test.txt","r")
>>>for line in f:
>>>    line = line.strip() #去掉每行两端的空字符
>>>    print line
    • 读取网络文件（爬虫）
    >>>import urllib
>>>url = "http://www.baidu.com"
>>>page = urllib.urlopen(url)
>>>for ling in page:
>>>    line = line.strip() #去掉每行两端的空字符
>>>    print line
    • 将两列若干行的txt文件数据放到一个列表里
    >>>f = open("test.txt","r") #读取文件
>>>a = [] #存放的列表a中
>>>for i in f:
>>>    b = i.split() #字符行转换为列表
>>>    for x in range(len(b)):
>>>        b[x] = float(b[x])
>>>    a.append(b) #将列表b添加到a中

    9.2 写入文件

    • 如果要写入的文件不存在，则会自动创建相应的文件并写入
    >>>f = open("test.txt","r") 
>>>f.write（“computer science") #写入，会覆盖源文件内容
>>>f.close()
    
>>>f = open("test.txt","a")  #"a"追加数据，不会覆盖
>>>f.write（“computer science") #写入，不会覆盖源文件内容
>>>f.close()

    9.3 文件的方法和属性

    read([size]) #以字符串 形式返回文件数据，可选的size参数用于说明读取的字节数
    readlines([size]) #将文件返回为行列表，可选参数size
    write(str) #将字符串写入文件
    close() #关闭句柄
    flush() #情况内部I/O缓存区，并将数据强行写回磁盘
    seek(pos) #移动到指定的文件位置（整数）
    tell() #以整数形式返回当前文件位置
    closed #如果文件已关闭，则为True

    10 集合与字典

    10.1 集合

    • 集合：无序、无重（等同数学上集合的定义）

    • 集合的运算
      并 union
      交 intersection
      添加 add
      移除 remove

    • add() #往集合中添加一个元素，如a.add(9)

    • clear() #移除集合中的所有元素，如 a.clear()
    • difference() #根据一个集合中不存在于另一个结合中的元素，创建处一个新的集合，如
    >>>a = set([0,1,2])
>>>b = set([1,3])
>>>a.difference(b)
set([0,2])
    • intersection() #根据两个集合中共有的元素，创建出一个新的集合
    >>>a = set([0,1,2])
>>>b = set([1,3])
>>>a.intersection(b)
set([1])
    • issubset() #判断一个集合的所有元素是否都包含于另一个集合
    >>>a = set([0,1,2])
>>>b = set([1,3])
>>>a.issubset(b)
False
    • remove() #移除集合中的一个元素
    >>>a = set([0,1,2])
>>>a.remove(1)
set([0,2])
    • symmetric_difference() #根据两个集合中所有不存在与对方的元素，创建出一个新的集合。即并集-交集
    >>>a = set([0,1,2])
>>>b = set([1,3])
>>>a.symmetric_difference(b)
set([0,2,3])
    • union() #并集
    >>>a = set([0,1,2])
>>>b = set([1,3])
>>>a.union(b)
set([0,1,2,3])
    • 散列表(hash table)
      散列表：用于存储集合的数据结构称为散列表，每当有元素加入到集合中时，Python就会计算该元素的散列码，散列码是一个整数。

    散列表元素可以是：布尔值、数字、字符串、元组tuple（不可是列表list）

    10.2 字典

    • 字典元素的删除
    >>>zidian = {"1":"cat","2":"dog"}
>>>del zidian["1"] #删除字典元素
>>>zidian
{"2":"dog"}
    • 字典的循环
    >>>zidian = {"1":"cat","2":"dog"}
>>>for i in zidian:
>>>    print i,zidian[i]
"1","cat"
"2","dog"
    • 字典方法
      clear() #清空字典内容 zidian.clear()
      get() #返回指定键所关联的值：如果指定键不存在，则返回默认值。如 zidian.get(‘1’,99)，若有“1”，则返回其值，若无，则返回99
    >>>zidian = {"1":"cat","2":"dog"}
>>>zidian.get("1",99)
>>>zidian.get("3",99)
'cat'
99

    keys() #以列表的形式返回字典的所有键。所得到的列表中国的每个条目肯定是唯一的。如 zidian.keys()

    >>>zidian = {"1":"cat","2":"dog"}
>>>zidian.keys()
['1','2']

    items() #返回(key, value)列表，zidian.items()

    >>>zidian = {"1":"cat","2":"dog"}
>>>zidian.items()
[('1','dog'),('2','cat')]

    values() #以列表的形式返回字典的所有值。所得列表中的每个条目不一定是唯一的。zidian.values()

    >>>zidian = {"1":"cat","2":"dog"}
>>>zidian.values()
['dog','cat']

    update() #用另一个字典的内容对当前字典进行更新。zidian.update()

    >>>zidian = {"1":"cat","2":"dog"}
>>>zidian2 = {"3":"tiger"}
>>>zidian.update(zidian2)
>>>zidian
{"1":"cat","2":"dog","3":"tiger"}

    11. 算法

    11.1 搜索

    • index() #索引
    >>>counts = [809,834,477,478,307]
>>>low = min(counts)
>>>min_index = counts.index(low) #索引方式counts.index()
>>>print min_index
4
    • 算法描述
    def find_two_smallest(L):
    '''Return a tuple of the indices of the two smallest values in list L.'''
    获取列表L中的最小元素
    找出这个最小元素的索引
    从列表中移除该元素
    找出列表L中新的最小元素的索引
    return 这两个索引

    def find_two_smallest(L):
    '''Return a tuple of the indices of the two smallest values in list L.'''
    smallest = min(L)
    min1 = L.index(smallest)
    L.remove(smallest)
    next_smallest = min(L)
    min2 = L.index(next_smallest)
    return 这两个索引

    11.2 计时

    注意算法的计算效率

    13 搜索与排序

    13.1 线性搜索

    • 常见的基本搜索
    >>>def linear_search(v,L):
>>>    i = 0
>>>    while i != len(L) and L[i] != v:
>>>        i += 1
>>>    return i
    • for循环型线性搜索
    >>>def linear_search(v,L):
>>>    i = 0
>>>    for value in L:
>>>        if value == v:
>>>            return i
>>>        i += 1
>>>    return len(L)
    • 哨兵搜索
    >>>def linear_search(v,L):
>>>    L.append(v)
>>>    i = 0
>>>    while L[i] != v:
>>>        i += 1
>>>    L.pop()
>>>    return i

    13.2 二分搜索

    • 二分搜索
    def binary_search(v,L):
i = 0
j = len(L) - 1
while i != j + 1:
    m = (i+j)/2
    if L[m] < v:
        i = m + 1
    else:
        j = m -1
if 0 <= i < len(L) and L[i] == v:
    return i
else:
    return -1

    13.3 排序

    • 选择排序（selcetion sort）
    def selection_sort(L):
    i = 0
    while i != len(L):
        smallest = find_min(L,i)
    L[i],L[smallest] = L[smallest], L[i]
    i += 1
def find_min(L,b):
    i = b + 1
    while i != len(L):
        if L[i] < L[smallset]:
        i += 1
    return smallest
    • 插入排序(升序)
    def insertion_sort(L):
    i = 0
    while i != len(L):
        insert(L,i)
        i += 1
def insert(L,b):
    #find where to insert L[b] by searching backwards from L[b] for a smaller item.
    i = b
    while i != 0 and L[i-1] <= L[b]:
        i = i - 1
    #move L[b] to index i, shifting the following values to the right.
    value = L[b]
    del L[b]
    L.insert(i,value)

    • 合并排序（merge sort）

    • 冒泡排序（bubble sort)

    • 快速排序（quick sort）
    • 堆排序（heap sort）

    14. 构建应用程序

    14.1 其它函数

    • 可变参数列表
    #求传入参数的最大值
def our_max(*values):
    '''Find the maximum of any number of values.'''
    if not values:
        return None
    m = values[0]
    for v in values[1:]:
        if v > m:
            m = v
    return
our_max(1)
1
our_max(1,2)
2
our_max(3,1,2,5,4,-17)
5

    values前面的*的作用：告诉python将当次调用的所有参数做成一个元组，并将该元组赋值给values。当没有提供任何值的时候，values就会被赋值为一个空元组。

    • 带*号的参数并不是必须单独出现。在函数的参数列表中，星号参数之前可以定义任意数量的常规。这些常规参数会按照正常的方式与值进行配对，然后将所有值做成一个元组并赋值给星号参数。
    def append_all(old, *new):
    for n in new:
        old.append(n)
    return old

values = []
append_all(values,1,2,3)

[1,2,3]

append_all(values)
[1,2,3]

    python不允许单个函数中出现两个或两个以上的星号参数，因为在将它们跟值进行配对的过程中会出现歧义。

    • 命名参数
      命名参数：不需要按照特定顺序将参数传入，只需将参数名及其值成对传入即可。
    def describe_creature(name, species, age, weight):
    return '%s (%s): %d years, %d kg' %(name,species,age,weight)

print describe_creature(name = 'Charles', species = 'Homo', age = 28, weight = 70)  #按照参数正常顺序传入
Charles(Homo): 28 years, 70 kg
    def describe_creature(name, species, age, weight):
    return '%s (%s): %d years, %d kg' %(name,species,age,weight)

print describe_creature(age = 28, species = 'Homo', name = 'Charles', weight = 70)  #变换参数顺序
Charles(Homo): 28 years, 70 kg

    14.2 异常

    14.3 测试

    14.4 调试

    14.5 模式

    15. 图形界面

    15.1 Tkinter模块

    from Tkinter import *
window = Tk()  #创建根窗口
    • Tkinter小插件
      Button #可点击的按钮
      Canvas #用于绘制或显示图形图像的区域
      Checkbutton #可点击的框，其状态可以是选定的或未选定的
      Entry #可供用户输入数据的单行文本框
      Frame #用于承载其他小插件的容器
      Label #用于显示文本框的单个行
      Listbox #可供用户选择的下拉菜单
      Menu #下拉菜单
      Messange #用于显示文本的多个行
      Menubutton #下拉菜单中的菜单项
      Text #可供用户输入数据的多行文本框
      TopLevel #额外的窗口
    from Tkinter import *
window = Tk()  #创建根窗口
label = Label(window, text = "this is our label.")
label.pack() #pack()方法

    • pack()方法，其它插件也可以用，用于将该插件置入其父插件中，并告诉其父插件要根据实际情况改变其大小。如果忘记了调用该方法，则子插件要么就不显示，要么就显示不正确。

    • Frame 组织其它插件

    from Tkinter import *
window = Tk()
frame = Frame(window)
frame.pack()
first = Label(frame, text = "first label")
first.pack()
second = Label(frame, text = "second label")
second.pack()
third = Label(frame, text = "third label")
third.pack()
window.mainloop()
    • Entry 可输入单行文本
    from Tkinter import *

window = Tk()

frame = Frame(window)
frame.pack()

var = StringVar()

label = Label(frame, textvariable = var)
label.pack()

entry = Entry(frame, textvariable = var)
entry.pack()

window.mainloop()

    15.2 模型、视图和控制器

    15.3 样式

    • 字体
    • 颜色
    • 布局

关键字：

上一篇： Python中如何使用装饰器？

下一篇： Python的Lock和conditio