一、 #!/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:
- 可以使用反斜杠()来实现多行语句
- 在 [], {}, 或 () 中的多行语句,不需要使用反斜杠()
- 反斜杠可以用来转义,使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示,并不是换行。r表示raw string,原始字符串
- 数字类型:int型包括长整型(Python2中是Long),bool型注意大写,float型3E-2表示3*10^-2,complex (复数), 如 1 + 2j、 1.1 + 2.2j
- 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 键时,程序将退出。
四、 数据类型
- Python变量不需要声明,自动分配类型
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "runoob" # 字符串
- Python允许你同时为多个变量赋值
a = b = c = 1
或者
a, b, c = 1, 2, "runoob"
- 标准数据类型
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开始
- 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()
复制列表
- 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)
将列表转换为元组
- 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)
- 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()
- 数据类型转换
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
五、 运算符
- 成员运算符
- 身份运算符
Tips:
is 与 == 区别:is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。
- 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) 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) -
随机数函数
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))
-
三角函数
-
数学常量
pi -------- 数学常量 pi(圆周率,一般以π来表示)
e -------- 数学常量 e,e即自然常数(自然常数) -
匿名函数
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
- 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
- 常见函数错误:
#!/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
七、 字符串
- 字符串格式化符号
- 三引号
python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。
para_str = “”“这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
“””
- 字符串内建函数
- 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中无指针
- 加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数
#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
输出:
70
(60, 50)
- 加了两个星号 ** 的参数会以字典的形式导入。
#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
输出:
1
{‘a’: 2, ‘b’: 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)