ErBing

往事已经定格,未来还要继续。

  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理

一、数据类型

  • 不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组)
  • 可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)

1.1 Number(数字)

Python3 支持 int、float、bool、complex(复数)。在Python 3里,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

isinstance 和 type 的区别在于:type()不会认为子类是一种父类类型。isinstance()会认为子类是一种父类类型。

1.1.1 类型转换

  • int(x) 将x转换为一个整数。

  • float(x) 将x转换到一个浮点数。

  • complex(x) 将x转换到一个复数,实数部分为 x,虚数部分为 0。

  • complex(x, y) 将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。

1.1.2 数字运算

 +, -, * 和 /,和其它语言(如Pascal或C)里一样。** 操作来进行幂运算。

在整数除法中,除法 / 总是返回一个浮点数,如果只想得到整数的结果,丢弃可能的分数部分,可以使用运算符 // 。// 得到的并不一定是整数类型的数,它与分母分子的数据类型有关系。

>>> 17 / 3  # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 17 % 3  # %操作符返回除法的余数
2
>>> 5 * 3 + 2 
17
>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128
View Code

1.1.3 数学函数

函数          返回值 ( 描述 )
abs(x)     返回数字的绝对值,如abs(-10) 返回 10
ceil(x)       返回数字的上入整数,如math.ceil(4.1) 返回 5
cmp(x, y)      如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃,使用 (x>y)-(x<y) 替换。

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的平方根。

 1.1.4 随机函数

函数描述
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]范围内。

 

1.2 String(字符串)

Python中的字符串用单引号 ' 或双引号 " 括起来,同时使用反斜杠 \ 转义特殊字符。

#!/usr/bin/python3

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次,也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

Python 使用反斜杠 \ 转义特殊字符,如果你不想让反斜杠发生转义,可以在字符串前面添加一个 r,表示原始字符串:

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob

另外,反斜杠(\)可以作为续行符,表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

1.2.1 转义字符

转义字符            描述
\(在行尾时)       续行符
\\                 反斜杠符号
\'                   单引号
\"                  双引号
\a                  响铃
\b                  退格(Backspace)
\000               空
\n                  换行
\v                  纵向制表符
\t                  横向制表符
\r                  回车,将 \r 后面的内容移到字符串开头,并逐一替换开头部分的字符,直至将 \r 后面的内容完全替换完成。
\f                  换页
\yyy              八进制数,y 代表 0~7 的字符,例如:\012 代表换行。
\xyy              十六进制数,以 \x 开头,y 代表的字符,例如:\x0a 代表换行
\other            其它的字符以普通格式输出

变量 a 值为字符串 "Hello",b 变量值为 "Python":1.2.2 字符串运算 

操作符描述实例
+ 字符串连接 a + b 输出结果: HelloPython
* 重复输出字符串 a*2 输出结果:HelloHello
[] 通过索引获取字符串中字符 a[1] 输出结果 e
[ : ] 截取字符串中的一部分,遵循左闭右开原则,str[0:2] 是不包含第 3 个字符的。 a[1:4] 输出结果 ell
in 成员运算符 - 如果字符串中包含给定的字符返回 True 'H' in a 输出结果 True
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True 'M' not in a 输出结果 True
r/R 原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。
print( r'\n' )
print( R'\n' )
% 格式字符串 请看下一节内容。

1.2.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

isnumeric() 如果字符串中只包含数字字符,则返回 True,否则返回 False

isspace() 如果字符串中只包含空白,则返回 True,否则返回 False.

istitle() 如果字符串是标题化的(见 title())则返回 True,否则返回 False

isupper() 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False

join(seq) 以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

len(string) 返回字符串长度

ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。

lower() 转换字符串中所有大写字符为小写.

lstrip() 截掉字符串左边的空格或指定字符。

maketrans() 创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。

max(str) 返回字符串 str 中最大的字母。

min(str) 返回字符串 str 中最小的字母。

replace(old, new [, max]) 把 将字符串中的 old 替换成 new,如果 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)) 以 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 参数中

upper() 转换字符串中的小写字母为大写

zfill (width) 返回长度为 width 的字符串,原字符串右对齐,前面填充0

isdecimal() 检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。

1.3 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) # 连接列表
['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

Python 列表截取可以接收第三个参数,参数作用是截取的步长。如果第三个参数为负数表示逆向读取,以下实例用于翻转字符串:

def reverseWords(input):
     
    # 通过空格将字符串分隔符,把各个单词分隔为列表
    inputWords = input.split(" ")
 
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ,而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空,表示移动到列表末尾
    # 第三个参数为步长,-1 表示逆向
    inputWords=inputWords[-1::-1]
 
    # 重新组合字符串
    output = ' '.join(inputWords)
     
    return output
 
if __name__ == "__main__":
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw)
# runoob like I
View Code

1.3.1 函数

len(list)  列表元素个数 

max(list) 返回列表元素最大值

min(list) 返回列表元素最小值

list(seq) 将元组转换为列表

1.3.2 方法

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( key=None, reverse=False) 对原列表进行排序

list.clear() 清空列表

list.copy() 复制列表

1.4 Tuple(元组)

元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开。tuple只有一个元素,需要在元素后添加逗号。

虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。 内置函数与list类似,只是list(seq)换为tuple(iterable)

#!/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) # 连接元组
('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

1.5 Set(集合)

集合(set)是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

创建格式:

parame = {value01,value02,...}
或者
set(value)
#!/usr/bin/python3

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合,重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素
{'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
Runoob 在集合中
{'b', 'c', 'a', 'r', 'd'}
{'r', 'b', 'd'}
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
{'c', 'a'}
{'z', 'b', 'm', 'r', 'l', 'd'}

1.5.1 集合操作

s.add(x) 将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。

s.update(x) 也可以添加元素,且参数可以是列表,元组,字典等

s.remove(x) 将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。

s.discard(x) 移除集合中的元素,且如果元素不存在,不会发生错误。

s.pop() 随机删除集合中的一个元素

len(s) 计算集合 s 元素个数。

s.clear() 清空集合 s。

x in s 判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False。

1.5.2 方法

add()为集合添加元素

clear()移除集合中的所有元素

copy()拷贝一个集合

difference()返回多个集合的差集

difference_update()移除集合中的元素,该元素在指定的集合也存在。

discard()删除集合中指定的元素

intersection()返回集合的交集

intersection_update()返回集合的交集。

isdisjoint()判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。

issubset()判断指定集合是否为该方法参数集合的子集。

issuperset()判断该方法的参数集合是否为指定集合的子集

pop()随机移除元素

remove()移除指定元素

symmetric_difference()返回两个集合中不重复的元素集合。

symmetric_difference_update()移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。

union()返回两个集合的并集

update()给集合添加元素

列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

1.6 Dictionary(字典)

字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(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' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值
1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

1.6.1 方法

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

二、条件控制

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

三、循环语句

3.1 while循环

while 判断条件(condition):
    执行语句(statements)……

在 Python 中没有 do..while 循环。

3.1.1 无限循环

while True:
    pass

3.1.2 while 循环使用 else 语句

在 while … else 在条件语句为 false 时执行 else 的语句块。

#!/usr/bin/python3
 
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")
0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

3.2 for循环

for <variable> in <sequence>:
    <statements>
else:
    <statements>
#!/usr/bin/python3
 
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")
-----------------------------------------------
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!
View Code

3.3 range()函数

如果你需要遍历数字序列,可以使用内置range()函数。

for i in range(5):
#区间:
for i in range(5,9) :
#指定不同的增量:
for i in range(0, 10, 3) :
#结合range()和len()函数
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):

3.4 break、continue、else

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止,任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句,然后继续进行下一轮循环。

循环语句可以有 else 子句,它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被 break 终止时不执行。

pass是空语句,是为了保持程序结构的完整性。 

四、函数

4.1  函数的创建和调用

def 函数名(参数列表):
    函数体
    [return xxx]
#!/usr/bin/python3
 
# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

4.2 函数的参数传递

4.2.1 位置实参

#!/usr/bin/python3
 
#可写函数说明
def printme(str1, str2):
   "打印任何传入的字符串"
   print (str1, str2)
   return
 
# 调用 printme 函数
a = 's'
b = 'w'
printme(a, b)

4.2.2 关键字参数

使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "菜鸟教程")

4.2.3 默认参数

调用函数时,如果没有传递参数,则会使用默认参数。以下实例中如果没有传入 age 参数,则使用默认值:

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

4.2.4 不定长参数

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号 * 的参数会以元组(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
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6

4.2.5 可更改(mutable)与不可更改(immutable)对象

在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象 

#不可变对象
def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a)
----------------
4379369136
4379369136
4379369424
#可变对象
#!/usr/bin/python3
 
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
---------------
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

 4.2.6 匿名函数

 python 使用 lambda 来创建匿名函数。只能写一行。

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

 五、python面向对象

类有一个名为 __init__() 的特殊方法(构造方法),该方法在类实例化时会自动调用,当然, __init__() 方法可以有参数,参数通过 __init__() 传递到类的实例化操作上。

类方法必须包含参数 self, 且为第一个参数,self 代表的是类的实例。

#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
   # 实例方法
def speak(self): print("%s 说: 我 %d 岁。" %(self.name,self.age))
# 静态方法,使用类名直接访问
@staticmethod
def sleep():
pass
# 类方法,使用类名直接访问
@classmethod
def eat(cls):
pass
#单继承示例 class student(people): grade = '' def __init__(self,n,a,w,g): #调用父类的构函 people.__init__(self,n,a,w) self.grade = g #覆写父类的方法 def speak(self): print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade)) #另一个类,多重继承之前的准备 class speaker(): topic = '' name = '' def __init__(self,n,t): self.name = n self.topic = t def speak(self): print("我叫 %s,我是一个演说家,我演讲的主题是 %s"%(self.name,self.topic)) #多重继承 class sample(speaker,student): a ='' def __init__(self,n,a,w,g,t): student.__init__(self,n,a,w,g) speaker.__init__(self,n,t) # 类实例化 s = student('ken',10,60,3) # 访问类的属性或方法 s.speak()
# 用子类对象调用父类已被覆盖的方法
# python2中调用super方法必须是新类(有继承的类),此时people应继承object。python3默认都是新类
super(student,s).speak()
# 类实例化 test = sample("Tim",25,80,4,"Python") # 访问类的属性或方法 test.speak() #方法名同,默认调用的是在括号中排前地父类的方法
ken 说: 我 10 岁了,我在读 3 年级
ken 说: 我 10 岁。
我叫 Tim,我是一个演说家,我演讲的主题是 Python

 5.2 特殊属性&方法

特殊属性:
__dict__ : 类或实例绑定的所有属性和方法的字典
__class__ : 所属类
__bases__ : 父类
__base__ : 第一个继承的父类
__mro__ : 类的层次结构
特殊方法:
__init__
: 构造函数,在生成对象时调用 __del__ : 析构函数,释放对象时使用 __repr__ : 打印,转换 __setitem__ : 按照索引赋值 __getitem__: 按照索引获取值 __len__: 获得长度 __cmp__: 比较运算 __call__: 函数调用 __add__: 加运算 __sub__: 减运算 __mul__: 乘运算 __truediv__: 除运算 __mod__: 求余运算 __pow__: 乘方
__subclasses__: 子类列表

 5.3 浅拷贝&深拷贝

浅拷贝:copy.copy拷贝时对象包含的子对象内容不拷贝,因此源对象和拷贝对象会引用同一个子对象

深拷贝:copy.deepcopy函数,递归拷贝对象中包含的子对象。

 六、File

6.1 open方法

Python open() 方法用于打开一个文件,并返回文件对象,在对文件进行处理过程都需要使用到这个函数,如果该文件无法被打开,会抛出 OSError。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

  • file: 必需,文件路径(相对或者绝对路径)。
  • mode: 可选,文件打开模式
  • buffering: 设置缓冲
  • encoding: 一般使用utf8
  • errors: 报错级别
  • newline: 区分换行符
  • closefd: 传入的file参数类型
  • opener: 设置自定义开启器,开启器的返回值必须是一个打开的文件描述符。
模式描述
t 文本模式 (默认)。
x 写模式,新建一个文件,如果该文件已存在则会报错。
b 二进制模式。
+ 打开一个文件进行更新(可读可写)。
U 通用换行模式(Python 3 不支持)。
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w 打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写

 6.2 File对象

file 对象使用 open 函数来创建,下表列出了 file 对象常用的函数:

file.close()关闭文件。关闭后文件不能再进行读写操作。

file.flush()刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。

file.isatty()如果文件连接到一个终端设备返回 True,否则返回 False。

file.read([size])从文件读取指定的字节数,如果未给定或为负则读取所有。

file.readline([size])读取整行,包括 "\n" 字符。

file.readlines([sizeint])读取所有行并返回列表,若给定sizeint>0,返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。

file.seek(offset[, whence])移动文件读取指针到指定位置

file.tell()返回文件当前位置。

file.truncate([size])从文件的首行首字符开始截断,截断文件为 size 个字符,无 size 表示从当前位置截断;截断之后后面的所有字符被删除,其中 windows 系统下的换行代表2个字符大小。

file.write(str)将字符串写入文件,返回的是写入的字符长度。

file.writelines(sequence)向文件写入一个序列字符串列表,如果需要换行则要自己加入每行的换行符。

6.3 with语句

with open('logo.png', 'rb') as img:
    img.read()

with语句自动管理上下文资源,不论什么原因跳出with块,都能确保文件能够正确关闭(自动调用特殊方法__exit()__),以此达到释放资源的目的。

 7. os模块

7.1 常用函数

os.getcwd() 返回当前工作目录

os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。 

os.mkdir(path[, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。 

os.makedirs(path[, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。

os.rmdir(path) 删除path指定的空目录,如果目录非空,则抛出一个OSError异常。

os.remove(path) 删除路径为path的文件。如果path 是一个文件夹,将抛出OSError; 查看下面的rmdir()删除一个 directory。

os.removedirs(path) 递归删除目录。

os.chdir(path) 改变当前工作目录。

7.2 os.path() 模块

os.path.abspath(path)     返回绝对路径
os.path.exists(path)     路径存在则返回True,路径损坏返回False
os.path.join(path1[, path2[, ...]])      把目录和文件名合成一个路径
os.path.splitext(path)     分割路径中的文件名与拓展名
os.path.basename(path)      返回文件名
os.path.dirname(path)     返回文件路径
os.path.isfile(path)     判断路径是否为文件
os.path.isdir(path)     判断路径是否为目录

 八、异常

8.1 异常处理

>>> def divide(x, y):
        try:
            result = x / y
        except ZeroDivisionError:
            print("division by zero!")
        else:
            print("result is", result)
        finally:
            print("executing finally clause")
   
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

首先,执行 try 子句(在关键字 try 和关键字 except 之间的语句)。如果没有异常发生,忽略 except 子句,try 子句执行后结束。如果在执行 try 子句的过程中发生了异常,那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符,那么对应的 except 子句将被执行。

else 子句将在 try 子句没有发生任何异常的时候执行。使用 else 子句比把所有的语句都放在 try 子句里面要好,这样可以避免一些意想不到,而 except 又无法捕获的异常。

finally 语句无论异常是否发生都会执行。

如果一个异常在 try 子句里(或者在 except 和 else 子句里)被抛出,而又没有任何的 except 把它截住,那么这个异常会在 finally 子句执行后被抛出。

8.2 抛出异常

raise [Exception [, args [, traceback]]]
try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')
    raise

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类(也就是 Exception 的子类)。

如果你只想知道这是否抛出了一个异常,并不想去处理它,那么一个简单的 raise 语句就可以再次把它抛出。

8.3 traceback模块

import logging
import traceback

try:
    raise NameError('HiThere')
except NameError:
    err_msg = traceback.format_exc()
    logging.info(err_msg)

 

posted on 2021-04-16 18:02  ErBing  阅读(15)  评论(0编辑  收藏  举报