Python3速成 笔记 备忘

一、 #！/usr/bin

#! /usr/bin/python3  
第一行注释标的是指向 python 的路径，告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器。


此外还有以下形式（推荐写法）：
#!/usr/bin/env python3

这种用法先在 env（环境变量）设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。

这是脚本语言共同遵守的规则：当第一行为 #!/path/to/script/interpreter时，指定了用来执行本脚本的解释器。
注意：
1、必须是文件的第一行
2、必须以#!开头
3、/path/to/script/interpreter是脚本解释器的全路径名。

#注释单行 ‘’‘注释一段‘’’ 且 单引号和双引号等价意义

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

二 、# -- coding: utf-8 --

Python2.x需要这句，否则无法编译中文注释等
Python3.x默认使用utf-8，若不需要中文可用其他替代

三、 import 模块

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

if True:
    print ("True")
else:
    print ("False")

由于缩进不一致，执行后会出现类似以下错误：
IndentationError: unindent does not match any outer indentation level

Tips:

1. 可以使用反斜杠()来实现多行语句
2. 在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()
3. 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。r表示raw string，原始字符串
4. 数字类型：int型包括长整型（Python2中是Long），bool型注意大写，float型3E-2表示3*10^-2，complex (复数), 如 1 + 2j、 1.1 + 2.2j
5. print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=" "

str='Runoob'
 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[0:5])            # 输出从第一个开始到第五个的字符
print(str[2:])             # 输出从第三个开始的后的所有字符
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 连接字符串
 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

等待用户输入

sentence = input()  # 一旦用户按下 enter 键时，程序将退出。

四、 数据类型

1. Python变量不需要声明，自动分配类型

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

2. Python允许你同时为多个变量赋值

a = b = c = 1
或者
a, b, c = 1, 2, "runoob"

3. 标准数据类型
   Python3 的六个标准数据类型中：
   不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
   可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

>>>5 // 2 # 除法，得到一个整数
2
>>>  2 ** 5 # 乘方
32

练习：
给一个string变量 ‘His house is big’
取出第一个字母和倒数第二个字母组成新单词

sentence = "His house is big"
print(sentence[0]+sentence[-2])
# Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始

4. List（列表）
   列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
   列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
   和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

实例：
#!/usr/bin/python3
 
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

del list[4] :   [ 'abcd', 786 , 2.23, 'runoob']

# 如果想初始化个长度为10的列表，可以按照下面的例子来实现:
list_empty = [None]*10 :  [None, None, None, None, None, None, None, None, None, None]

列表的拼接
squares = [1, 4, 9, 16, 25]
squares += [36, 49, 64, 81, 100]
squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表嵌套
a = [‘a’, ‘b’, ‘c’]
n = [1, 2, 3]
x = [a, n]
x : [[‘a’, ‘b’, ‘c’], [1, 2, 3]]
x[0] : [‘a’, ‘b’, ‘c’]
x[0][1] : ‘b’

列表函数

列表方法

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

5. Tuple（元组）
   元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。(不加括号也可以tup3 = “a”, “b”, “c”, “d”）
   修改元组元素的操作是非法的
   TypeError: ‘tuple’ object does not support item assignment

#!/usr/bin/python3
 
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
 
print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

特殊：
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

Tips：

• 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
• 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

元组内嵌函数

• len(tuple)
  计算元组元素个数
• max(tuple)
  返回元组中元素最大值
• min(tuple)
  返回元组中元素最小值
  tuple(seq)
  将列表转换为元组

6. Dictionary（字典）
   字典（dictionary）是Python中另一个非常有用的内置数据类型。
   列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
   字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
   键(key)必须使用不可变类型。
   在同一个字典中，键(key)必须是唯一的。

#!/usr/bin/python3
 
dict = {}
dict['one'] = "1 - 教程"
dict[2]     = "2 - 工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
 
print (dict['one'])       # 输出键为 'one' 的值   1 - 教程
print (dict[2])           # 输出键为 2 的值          2 - 工具
print (tinydict)          # 输出完整的字典   {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print (tinydict.keys())   # 输出所有键    dict_keys(['name', 'code', 'site'])
print (tinydict.values()) # 输出所有值   dict_values(['runoob', 1, 'www.runoob.com'])
 

字典内置函数

内置方法

• clear() 删除字典内所有元素
• copy() 返回一个字典的浅复制
• fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
• get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
• key in dict 如果键在字典dict里返回true，否则返回false]
• items() 以列表返回可遍历的(键, 值) 元组数组
• keys() 返回一个迭代器，可以使用 list() 来转换为列表
• setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
• update(dict2) 把字典dict2的键/值对更新到dict里
• values() 返回一个迭代器，可以使用 list() 来转换为列表
• pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
• popitem()随机返回并删除字典中的一对键和值(一般删除末尾对)

#!/usr/bin/python3
# 记录等级小程序 

student = {}
write = 1
while write:
    name = str(input("请输入姓名："))
    grade = int(input("请输入成绩："))
    student[str(name)] = grade
    write = int(input("是否继续输入？是按1否则按0"))

print('姓名    等级'.center(20))
for key,value in student.items():
    if value >= 90:
        print('%s  A'.center(20)%key)
    elif 90>value>= 60:
        print('%s  B'.center(20)%key)
    else:
        print('%s  C'.center(20) % key)

7. Set（集合）
   集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
   基本功能是进行成员关系测试和删除重复元素。
   可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

#!/usr/bin/python3
 
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 
print(student)   # 输出集合，重复的元素被自动去掉
#  {'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
 
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
 # Rose 在集合中
 
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
 
print(a)          # {'b', 'a', 'c', 'r', 'd'}
 
print(a - b)     # a 和 b 的差集   {'b', 'd', 'r'}
 
print(a | b)     # a 和 b 的并集 {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
 
print(a & b)     # a 和 b 的交集  {'a', 'c'}
 
print(a ^ b)     # a 和 b 中不同时存在的元素 {'l', 'r', 'z', 'm', 'b', 'd'}

添加元素 ： s.add( x )
移除元素： s.remove( x )
或者   s.discard( x )  （不存在时也不会报错）
随机删除集合中一个元素或者删除集合中第一个元素：s.pop() 
计算集合元素个数 ： len(s)
清空集合: s.clear()

8. 数据类型转换
   1） 将x转换为一个整数： int(x [,base])

>>>int()               # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa',16)  
10  
>>> int('10',8)  
8

2） 将x转换到一个浮点数 ：float(x)

>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0

3） 创建一个复数： complex(real [,imag])

>>>complex(1, 2)
(1 + 2j)
>>> complex(1)    # 数字
(1 + 0j)
>>> complex("1")  # 当做字符串处理
(1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

4）将对象 x 转换为字符串：str(x)
将对象 x 转换为表达式字符串：repr(x） repr() 函数将对象转化为供解释器读取的形式。
5） 用来计算在字符串中的有效Python表达式,并返回一个对象：eval(str)

>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4

6） 将序列 s 转换为一个元组：tuple(s)
将序列 s 转换为一个列表： list(s)
将序列 s 转换为可变集合：set(s)
创建一个字典。d 必须是一个序列 (key,value)元组： dict(d)
转换为不可变集合： frozenset(s)
将一个整数转换为一个字符：chr(x)
将一个字符转换为它的整数值： ord(x)
将一个整数转换为一个十六进制字符串：hex(x)
将一个整数转换为一个八进制字符串：oct(x)

Tips：
python 中数字有以下的表示方式：

2 进制是以 0b 开头的: 例如: 0b11 则表示十进制的 3

8 进制是以 0o 开头的: 例如: 0o11 则表示十进制的 9

16 进制是以 0x 开头的: 例如: 0x11 则表示十进制的 17

五、 运算符

1. 成员运算符
   
2. 身份运算符
   

Tips：
is 与 == 区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

3. Python无 ++ – 自增 自减运算符
   python 与 c 语言概念上的一些差异，直接上例子：

b = 5
a = 5
id(a)
162334512
id(b)
162334512
a is b
True

可以看出， python 中，变量是以内容为基准而不是像 c 中以变量名为基准，所以只要你的数字内容是5，不管你起什么名字，这个变量的 ID 是相同的，同时也就说明了 python 中一个变量可以以多个名称访问。
这样的设计逻辑决定了 python 中数字类型的值是不可变的，因为如果如上例，a 和 b 都是 5，当你改变了 a 时，b 也会跟着变，这当然不是我们希望的。

因此，正确的自增操作应该 a = a + 1 或者 a += 1，当此 a 自增后，通过 id() 观察可知，id 值变化了，即 a 已经是新值的名称。
但是 当a和b超过（-5，256）间的数这个范围的时候，两个变量就会指向不同的对象了，因此地址也会不一样，

a=1000
b=1000
id(a);id(b)

2236612366224
2236617350384

六、 函数

1. 常用数学函数
   1） abs(x) -------- 返回数字的绝对值，如abs(-10) 返回 10
   2） fabs(x) -------- 返回数字的绝对值，如math.fabs(-10) 返回10.0
   3）max(x1, x2,…) -------- 返回给定参数的最大值，参数可以为序列
   4）min(x1, x2,…) -------- 返回给定参数的最小值，参数可以为序列
   5） sqrt(x) -------- 返回数字x的平方根
   6）pow(x, y) -------- x**y 运算后的值
   7）ceil(x) -------- 返回数字的上入整数，如math.ceil(4.1) 返回 5
   8）floor(x) -------- 返回数字的下舍整数，如math.floor(4.9)返回 4
   9）round(x [,n]) -------- 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数，如round(56.659,1) : 56.7 “4舍6入5看齐,奇进偶不进”
   10）log(x) -------- 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
   11）log10(x) -------- 返回以10为基数的x的对数，如math.log10(100)返回 2.0
   12）exp(x) -------- 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
   13）modf(x) -------- 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。如math.modf(100.72) : (0.7199999999999989, 100.0)

2. 随机数函数
   1）choice(seq) -------- 从序列的元素中随机挑选一个元素，比如

#!/usr/bin/python3
import random

print ("从 range(100) 返回一个随机数 : ",random.choice(range(100)))  # 从0到99中随机挑选一个整数
print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9]))
print ("从字符串中 'Runoob' 返回一个随机字符 : ", random.choice('Runoob'))

2）shuffle(lst) -------- 将序列的所有元素随机排序

#!/usr/bin/python3
import random
 
list = [20, 16, 10, 5];
random.shuffle(list)
print ("随机排序列表 : ",  list)
 
random.shuffle(list)
print ("随机排序列表 : ",  list)

3）randrange ([start,] stop [,step]) -------- 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1

#!/usr/bin/python3
import random

# 从 1-100 中选取一个奇数
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))
# 从 0-99 选取一个随机数
print ("randrange(100) : ", random.randrange(100))

4）random() -------- 随机生成下一个实数，它在[0,1)范围内。

random.random() ：   0.09690599908884856

5）seed([x]) -------- 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed （可不了解）

6）randint(x,y) -------- 随机生一个整数int类型，可以指定这个整数的范围

random.randint(1000,9999)
8449

6）uniform(x, y) -------- 随机生成浮点数，它在[x,y]范围内。

#!/usr/bin/python3
import random

print ("uniform(5, 10) 的随机浮点数 : ",  random.uniform(5, 10))
print ("uniform(7, 14) 的随机浮点数 : ",  random.uniform(7, 14))

3. 三角函数
   

4. 数学常量
   pi -------- 数学常量 pi（圆周率，一般以π来表示）
   e -------- 数学常量 e，e即自然常数（自然常数）

5. 匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

相加后的值为 : 30
相加后的值为 : 40

6. global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

以下实例修改全局变量 num：

#!/usr/bin/python3
 
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

1
123
123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

#!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

100
100

7. 常见函数错误：

#!/usr/bin/python3
 
a = 10
def test():
    a = a + 1
    print(a)
test()

Traceback (most recent call last):
File “test.py”, line 7, in
test()
File “test.py”, line 5, in test
a = a + 1
UnboundLocalError: local variable ‘a’ referenced before assignment

修改：

#!/usr/bin/python3
 
a = 10
def test(a):
    a = a + 1
    print(a)
test(a)

11

七、 字符串

1. 字符串格式化符号
   
2. 三引号
   python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

para_str = “”“这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
“””

3. 字符串内建函数

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

八、 *星号

Python中无指针

1. 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

输出:
70
(60, 50)

2. 加了两个星号 ** 的参数会以字典的形式导入。

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

输出:
1
{‘a’: 2, ‘b’: 3}

3. 声明函数时，参数中星号 * 可以单独出现，例如:

def f(a,b,*,c):
return a+b+c

如果单独出现星号 * 后的参数必须用关键字传入。

def f(a,b,*,c):
    return a+b+c

f(1,2,3) # 报错
Traceback (most recent call last):
File “”, line 1, in
TypeError: f() takes 2 positional arguments but 3 were given
f(1,2,c=3) # 正常
6

九、 堆栈

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
stack
[3, 4, 5, 6, 7]
stack.pop()
7
stack
[3, 4, 5, 6]
stack.pop()
6
stack.pop()
5
stack
[3, 4]

十、 队列

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

from collections import deque
queue = deque([“Eric”, “John”, “Michael”])
queue.append(“Terry”) # Terry arrives
queue.append(“Graham”) # Graham arrives
queue.popleft() # The first to arrive now leaves
‘Eric’
queue.popleft() # The second to arrive now leaves
‘John’
queue # Remaining queue in order of arrival
deque([‘Michael’, ‘Terry’, ‘Graham’])

十一、 __name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
每个模块都有一个__name__属性，当其值是’main’时，表明该模块自身在运行，否则是被引入。

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

$ python using_name.py
程序自身在运行

$ python
import using_name
我来自另一模块

十二、 常用时间处理方法

• 今天 today = datetime.date.today()
• 昨天 yesterday = today - datetime.timedelta(days=1)
• 上个月 last_month = today.month - 1 if today.month - 1 else 12
• 当前时间戳 time_stamp = time.time()
• 时间戳转datetime datetime.datetime.fromtimestamp(time_stamp)
• datetime转时间戳 int(time.mktime(today.timetuple()))
• datetime转字符串 today_str = today.strftime("%Y-%m-%d")
• 字符串转datetime today = datetime.datetime.strptime(today_str, “%Y-%m-%d”)
• 补时差 today + datetime.timedelta(hours=8)