python基础

变量赋值

单变量赋值

python中的变量赋值不需要声明类型, 但是变量使用前必须要先赋值, 用等号=来给变量赋值

counter = 100  

多变量赋值

在 Python 中，多变量赋值是指同时给多个变量赋值。这是通过将多个变量名列在左侧，并将它们与右侧的值列表一一对应来实现的

a = b = c = 1

a = b = c = 1

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

a, b, c = [1, 2, 3]

数据类型

python3中有6个标准的数据类型:

• Number：数字

• String：字符串

• List：列表

• Tuple：元组

• Set：集合

• Dictionary：字典

Number类型

定义

Python3 支持 int、float、bool、complex(复数)

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'>

print(isinstance(a, int)) #输出True

数字类型转换

a = 1.0
b = 3
print(int(a)) #输出1
print(float(b)) #输出3.0

运算

print(17//3)   #输出5
print(17%3)    #求余,输出2
print(5**2)    #求平方,输出25
print(25**0.5) #开根号，输出5.0

相关函数

Number类型函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
math.ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
math.floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
math.exp(x)	返回e的x次幂,如math.exp(1) 返回2.718281828459045
math.log10(x)]	返回以10为基数的x的对数，如math.log10(100)返回2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。例如max([1,2,3,4]), 返回4
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
math.pow(x, y)	返回x**y运算后的值。
round(x,n)	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
math.sqrt(x)	返回数字x的平方根。如math.sqrt(100)返回10

String类型

定义

可对字符串进行切片操作

str = 'HelloWorld'
print(str)          # 输出字符串: HelloWorld
print(str[0:-1])    # 输出第一个到倒数第二个的所有字符: HelloWorl
print(str[0])       # 输出字符串第一个字符: H
print(str[2:5])     # 输出从第三个开始到第五个的字符: llo
print(str[2:])      # 输出从第三个开始的后的所有字符: lloWorld
print(str * 2)      # 输出字符串两次: HelloWorldHelloWorld
print(str + "TEST") # 连接字符串: HelloWorldTEST 

字符串格式化

字符串格式符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数(大写)
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数, 默认保留6位小数
%E	作用同%e，用科学计数法格式化浮点数
%g	根据数值的大小采用%f和%e
%G	作用同%g
%p	用十六进制数格式化变量的地址

print("%.2f"%(10.556)) #输出10.56
print ("我叫%s今年%d岁" % ('henry', 20))  #输出:我叫henry今年20岁
print("%x" % 16) #输出16的十六进制数: 10
print("%e" % 10000) #输出: 1.000000e+04,
print("%.3e" % 0.001) #输出: 1.000e-03
print("%g" % 1000) #输出: 1000
print("%g" % 1000000000) #输出: 1e+09

多行字符串

python可以使用三引号"""包裹多行字符串

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
"""
print(para_str)

str.format()

str.format的常用语法:

print("MY NAME IS {},AGE is {}".format('herry','15'))
#输出MY NAME IS herry,AGE is 15

可在format()使用位置参数

>>> print('{0} 和 {1}'.format('Henry', 'Tom'))
Henry 和 Tom
>>> print('{1} 和 {0}'.format('Henry', 'Tom'))
Tom 和 Henry

可在format()使用关键字参数, 它们的值会指向使用该名字的参数

print("MY NAME IS {name},AGE is {age}".format(name='herry',age='15'))
#输出MY NAME IS herry,AGE is 15

也可以位置参数和关键字参数混合

print('名字列表 {0}, {1}, 和 {other}。'.format('Henry', 'Tom', other='Lee'))
#输出:名字列表 Henry, Tom, 和 Lee。

通过:和格式符号可以对值更好的格式化, 例如保留小数点后几位

import math
print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi)) #输出:常量 PI 的值近似为 3.142。

在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
for name, number in table.items():
    print('{0:10} ==> {1:10d}'.format(name, number))

#输出内容如下:        
#Google     ==>          1
#Runoob     ==>          2
#Taobao     ==>          3

f-string

f-string是 python3.6之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

格式化字符串以 f 开头, 后面接着字符串, 字符串中的表达式用大括号**{}**包起来，它会将变量或表达式计算后的值替换进去

name = 'Herry'
print(f'Hello {name}') #输出Hello Herry
print(f'{1+2}') #输出3

a = {'id':1,'name':'faker'}
print(f'我叫{a["name"]},排名第{a["id"]}') #我叫faker,排名第1

相关函数

python函数	描述
len(str)	返回字符串str的长度
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。

String内置函数	描述
str.capitalize()	将字符串的第一个字符转换为大写
str.center(width,fillchar)	返回一个宽度为width, str居中的字符串，fillchar为填充的字符, 默认为空格。
str.count(sub, beg= 0,end=len(string))	返回sub在 str 里面出现的次数，如果 beg 或者 end 指定了, 则返回指定范围内 str 出现的次数
bytes.decode(encoding="utf-8")	Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来对bytes对象进行解码，这个bytes对象可以由 str.encode() 来编码返回。
str.encode(encoding='UTF-8')	对字符串str进行encoding 指定的编码格式编码, 返回bytes对象
str.endswith(suffix, beg=0, end=len(string))	检查str是否以suffix结束，如果beg 或者 end 指定, 则检查指定的范围内是否以suffix结束，如果是，返回 True,否则返回 False.
str.expandtabs(tabsize=8)	把字符串str中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
str.find(sub, beg=0, end=len(str))	检测 sub 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
str.index(sub, beg=0, end=len(string))	跟find()方法一样，只不过如果sub不在字符串中会报一个异常。
str.isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
str.isalpha()	如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
str.isdigit()	如果字符串只包含数字则返回 True 否则返回 False..`
str.islower()	`如果字符串的字符全是小写字母则返回 True，否则返回 False
str.isnumberic()	如果字符串中只包含数字字符，则返回 True，否则返回 False
str.isspace()	如果字符串中只包含空白，则返回 True，否则返回 False.
str.istitle()	如果字符串是标题化的(见 title())则返回 True，否则返回 False
str.isupper()	如果字符串中的字符全是大写，则返回 True，否则返回 False
str.join(seq)	以指定字符串str作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
str.ljust(width,fillchar)	返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
str.lower()	转换字符串中所有大写字符为小写.
str.lstrip(chars)	截掉字符串左边的空格或指定字符chars。
str.replace(old,new)	把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
str.rjust(width,fillchar)	返回一个原字符串右对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
str.rstrip(chars)	删除字符串末尾的空格或指定字符chars。
str.split(chars="")	以 chars为分隔符对字符串str进行切片来返回列表
str.splitlines(keepends)	按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
str.startswith(substr, beg=0,end=len(string))	检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
str.strip(chars)	在字符串上执行 lstrip()和 rstrip()
str.swapcase()	将字符串中大写转换为小写，小写转换为大写
str.title()	返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写
str.upper()	转换字符串中的小写字母为大写
str.isdecimal	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

List类型

定义

列表可以使用方括号 [] 来定义，元素之间使用逗号 , 分隔

# 定义一个空列表
lst = []

# 定义一个包含整数的列表
lst = [1, 2, 3, 4, 5]

# 定义一个包含字符串的列表
lst = ['apple', 'banana', 'cherry']

# 定义一个包含多种类型元素的列表
lst = [1, 'apple', 3.14, [1, 2, 3]]

常用操作

读取列表元素和列表的切片与拼接

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print(list)            # 输出完整列表:['abcd', 786, 2.23, 'runoob', 70.2]
print(list[0])         # 输出列表第一个元素:abcd

print(list[1:3])       # 从第二个开始输出到第三个元素:[786, 2.23]
print(list[2:])        # 输出从第三个元素开始的所有元素:[2.23, 'runoob', 70.2]
print(list[-1])        # 输出最后一个元素70.2
print(list[0:-2])      # 输出第一个至倒数第三个元素:['abcd', 786, 2.23]

print(list[1:])        # 输出[786, 2.23, 'runoob', 70.2]
print(list[1::2])      # 输出[786, 'runoob']
print(list[::-1])      # 逆序输出[70.2, 'runoob', 2.23, 786, 'abcd']

print(tinylist * 2)    # 输出两次列表:[123, 'runoob', 123, 'runoob']
print(list + tinylist) # 拼接列表,输出['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

列表与字符串不一样的是, 列表的元素是可以改变的

a = [1,2,3,4,5,6]
a[0] = 9
a[2:5] = [13,14,15]
print(a) #输出[9, 2, 13, 14, 15, 6]

a[2:5] = [] #设置对应的元素为空
print(a) #输出[9, 2, 6]

更新列表元素

list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
 
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

删除列表元素

list = ['Google', 'Runoob', 1997, 2000]
print("原始列表 : ", list) #输出: ['Google', 'Runoob', 1997, 2000]
del list[2]
print("删除后的列表: ", list) #输出: ['Google', 'Runoob', 2000]

相关函数

python内置函数	描述
len(list)	返回列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值

list函数	描述
list(seq)	将元组(序列)转换为列表
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	返回某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值, 此序列可以是列表,元组,集合
list.index(obj,start)	返回obj元素在列表匹配的第一个索引位置, start表示查找的起始位置
list.insert(index,obj)	在列表的指定索引插入元素
list.pop(index)	移除列表的指定索引元素, 若index为空则默认移除最后一个元素
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	逆转列表元素的索引位置

list.sort(key=None,reverse=False)

key: 将key作标准来进行排序, 可以是表达式或者函数

reverse: False表示升序, True表示降序

如下代码所示, 将列表元素按字符串长度进行排序输出, 以下有两种解决思路:

fruits = ['grape','pear','apple','water melon']

#lambda声明匿名函数,使用格式为lambda arguments : expression,执行表达式并返回结果
fruits.sort(key=lambda x:len(x))  
print(fruits)

fruits = ['grape','pear','apple','water melon']
fruits.sort(key=len)
print(fruits)

元组类型

定义

元组与列表类似，但是元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
print(type(tup3))  #tup1,tup2,tup3均为元组类型

若元组中只包含一个元素，则需要在元素后面添加逗号, 否则()会被识别成运算符

tup1 = (60)
print(type(tup1))  #输出<class 'int'>

tup2 = (60,)
print(type(tup2))  #输出<class 'tuple'>

常用操作

使用下标索引来访问元组中的值, 也可以对元组进行切片操作

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print(tup1[0])   #输出Google
print(tup2[1:5]) #输出(2, 3, 4, 5)

虽然元组中的元素值是不允许修改的，但可以对元组进行拼接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print (tup3)  #输出(12, 34.56, 'abc', 'xyz')

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('Google', 'Runoob', 1997, 2000) 
del tup
print (tup) #输出直接报错,因为元组已被删除

相关函数

python内置函数	描述
len(tuple)	计算元组元素个数
max(tuple)	返回元组中元素最大值
min(tuple)	返回元组中元素最小值
tuple(iterable)	将可迭代系列转换为元组。

字典类型

定义

字典用大括号**{}**来定义。

键必须是唯一的, 值是可变的。

mydict = {'name': 'runoob', 'likes': 123, 1: 'www.runoob.com'}

print(mydict[1])      #输出www.runoob.com
print(mydict['name']) #输出runoob

常用操作

使用dict()函数创建字典

emptyDict = dict()

print(emptyDict) #输出空字典:{}

print(len(emptyDict)) #输出字典的长度:0

访问字典的值

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print (tinydict['Name']) #输出
print (tinydict['Age'])

修改和更新字典的值

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "北京大学"    # 添加信息
 
 
print (tinydict['Age'])     #输出8
print (tinydict['School'])  #输出'北京大学'

删除字典元素

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print (tinydict['Age'])  #输出直接报错,因为字典已被删除

相关函数

函数	描述
len(dict)	计算字典元素个数, 即键的总数。
str(dict)	用字符串的形式输出字典, 例如输出:"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.fromkeys(seq,values)	用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值
dict.get(key,[value])	返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。
key in dict	如果键在字典dict里返回true，否则返回false
dict.items()	Python 字典 items() 方法以列表返回视图对象，是一个可遍历的key/value 对
dict.keys() dict.values()	返回一个视图对象
dict.pop(key)	删除字典key键所对应的值，返回被删除的值
dict.popitem()	返回并删除字典中最后一对键和值

dict.fromkeys(seq,values)

country = ['China','England','America','France']
dict = {}
dict = dict.fromkeys(country,'')
print(dict)

使用dict.items()同时遍历字典的键与值, 使用dict.keys()和dict.values()分别遍历字典的键与值

dict = {'China':1,'England':2,'America':3,'France':4}

for key,value in dict.items():
    print(key+"  ===>  "+str(value))
    '''输出如下:
        China  ===>  1
        England  ===>  2
        America  ===>  3
        France  ===>  4
    '''
for key in dict.keys():
    print(key)
    '''输出如下:
        China
        England
        America
        France
    '''

for value in dict.values():
    print(value)
    '''输出如下:
         1
         2
         3
         4   
    '''

集合类型

定义

集合是一个无序的不重复元素序列, 使用大括号**{ }或set()**函数来创建

常用操作

以下是两个集合之间的运算

a = set('abacha')
print(a) #输出{'c', 'a', 'h', 'b'}

b = set('jabka')
print(b) #输出{'k', 'a', 'j', 'b'}

print(a|b) #输出a与b的并集:{'a', 'k', 'b', 'h', 'j', 'c'},
print(a&b) #输出a与b的交集:{'b', 'a'}
print(a^b) #输出不同时包含于a和b的元素:{'c', 'j', 'h', 'k'}

集合添加元素: set.add()、set.update()

thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset) #输出{'Taobao', 'Runoob', 'Facebook', 'Google'}

thisset.update([1,2])
print(thisset) #输出{1, 2, 'Taobao', 'Runoob', 'Facebook', 'Google'}

集合移除元素: set.remove(element)、set.discard(element)、set.pop()

thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao") #若元素不存在则会报错
print(thisset) #输出{'Google', 'Runoob'}

thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Taobao") #若元素不存在不会报错
print(thisset) #输出{'Google', 'Runoob'}

thisset = set(("Google", "Runoob", "Taobao"))
x = thisset.pop() #随机删除一个元素

求集合元素的个数: len(set)

thisset = set(("Google", "Runoob", "Taobao"))
print(len(thisset)) #输出3

清空集合元素: set.clear()

thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset) #输出set()

强制转换

在 Python 中，可以使用一些内置的函数来强制转换数据类型

强制转换函数	描述
int(x)	将x转换为一个整数
float(x)	将x转换到一个浮点数
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)	将一个整数转换为一个字符
ord(x)	将一个字符转换为ASCII码
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

推导式

定义

Python 推导式可实现从一个数据序列构建另一个新的数据序列

Python 支持各种数据结构的推导式

• 列表推导式

• 字典推导式

• 集合推导式

• 元组推导式

列表推导式

过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：

names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_names = [name.upper() for name in names if len(name)>3]
print(new_names) #输出:['ALICE', 'JERRY', 'WENDY', 'SMITH']

计算 30 以内可以被 3 整除的整数

multiples = [i for i in range(30) if i % 3 == 0]
print(multiples) #输出:[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

字典推导式

将列表转换成字典, 其中键为字符串值, 值为字符串长度

listdemo = ['Google','Runoob', 'Taobao']
newdict = {key:len(key) for key in listdemo}
print(newdict)  #输出{'Google': 6, 'Runoob': 6, 'Taobao': 6}

集合推导式

判断不是abc的字母并输出

a = {x for x in 'abracadabra' if x not in 'abc'}
print(a) #输出{'d', 'r'}

元组推导式

生成一个包含1~9的元组

a = (x for x in range(1,10))
print(a) #输出生成器对象:<generator object <genexpr> at 0x000001DB1C5EF270>
print(tuple(a))  #(1, 2, 3, 4, 5, 6, 7, 8, 9)

迭代器与生成器

迭代器

定义

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退

迭代器主要涉及两个函数: iter()和next()

• iter(): 将可迭代对象转换为迭代器

• next(): 依次访问迭代器里面的函数

常用操作

创建迭代器对象

list=[1,2,3,4]
it = iter(list) #创建迭代器对象
print(next(it))  #输出1
print(next(it))  #输出2

for语句遍历迭代器对象

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ") #输出1 2 3 4

生成器

定义

在 Python 中，有一种特殊的函数叫做生成器，它使用 yield 关键字返回值。生成器能够在循环的过程中不断推算出后续的值，而不必创建完整的列表，从而节省空间。

列表生成式是一种快速创建列表的方式，但当列表中的元素数量很多时，会占用大量的存储空间。使用生成器能够在循环的过程中推算出后续的元素，而不必一次性创建完整的列表。这样就能节省大量的空间

常用操作

著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到, 例如:1, 1, 2, 3, 5, 8, 13, 21, 34, ...

def fib(sum):
    a, b, c = 0, 1, 0
    while c < sum:
        yield b        # 代码执行到这里，会跳出这个函数，并将b的值返回到使用next的代码处
        a, b = b, a + b
        c += 1

p = fib(6)
print(next(p)) #输出1
print(next(p)) #输出1
print(next(p)) #输出2
print(next(p)) #输出3
print(next(p)) #输出5
print(next(p)) #输出8

在 Python 中，生成器函数使用 yield 语句返回值，而不是使用 return 语句。如果想要在生成器中使用 return 语句, 可通过捕获生成器的 StopIteration 异常。当生成器的 return 语句被执行时，会抛出 StopIteration 异常，并结束生成器的执行, return语句的返回值包含在StopIteration的value中

def fib(sum):
    a, b, c = 0, 1, 0
    while c < sum:
        yield b
        a, b = b, a + b
        c += 1
    return "返回值只能传递给异常"

g = fib(3)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
         print('Generator return value:', e.value)
         break
 def fib(sum):
    a, b, c = 0, 1, 0
    while c < sum:
        yield b
        a, b = b, a + b
        c += 1
    return "返回值只能传递给异常"

g = fib(3)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
         print('Generator return value:', e.value)
         break
"""
输出如下所示：
g: 1
g: 1
g: 2
Generator return value: 返回值只能传递给异常
"""       

函数

参数

1.必须参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样，调用 printme() 函数，你必须传入一个参数，不然会出现语法错误

def printme(str):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用printme 函数，不加参数会报错
printme()

2.关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值

def printme(str):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme(str="HelloWorld") #输出"HelloWorld"

3.默认参数

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

# 可写函数说明
def printinfo(name, age=35):
    "打印任何传入的字符串"
    print("名字: ", name)
    print("年龄: ", age)
    return


# 调用printinfo函数
printinfo(name="Henry", age=22)  #输出:"名字:Henry 年龄:22"
printinfo(name="Tom")            #输出:"名字:Tom   年龄:35"

4.不定长参数

不定长参数是指函数的参数个数是不确定的。不定长参数可以接受任意数量的参数，并将它们作为一个元组返回

可以使用 * 操作符定义不定长参数。例如，下面是一个函数，它使用不定长参数计算传入的所有数字的平均值

def avg(*args):
    total = 0
    for arg in args:
        total += arg
    return total / len(args)

print(avg(1, 2, 3))  # 2.0
print(avg(1, 2, 3, 4, 5))  # 3.0
print(avg())  # 0.0

不定长关键字参数可以接受任意数量的关键字参数，并将它们作为一个字典返回

在 Python 中，可以使用 ** 操作符定义不定长关键字参数。例如下面是一个函数，它使用不定长关键字参数打印传入的所有关键字参数

def my_func(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

my_func(a=1,b=2,c=3)

'''
Output:
a: 1
b: 2
c: 3
'''

匿名函数

定义

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

虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

lambda 函数的使用语法如下：

lambda [arg1 [,arg2,.....argn]]:expression

使用实例

定义一个返回两个参数相加后的结果的匿名函数

sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

#输出结果如下：
#相加后的值为 :  30
#相加后的值为 :  40

读写文件

文件模式

模式	描述	若文件不存在
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。	出错
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。	出错
r+	打开一个文件用于读写。文件指针将会放在文件的开头。	出错
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。	出错
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。	建立
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。	建立
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。	建立
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。	建立
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件进行写入。	建立
ab	以而二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件进行写入。	建立
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写	建立
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写	建立

file对象函数

file对象函数	描述
file.close()	关闭文件。
file.flush()	刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入
file.fileno()	返回一个整型的文件描述符, 可以用在如os模块的read方法等一些底层操作上
file.isatty()	如果文件连接到一个终端设备返回 True，否则返回 False
file.read([size])	从文件读取指定的字节数，如果未给定或为负则读取所有
file.readline([size])	读取整行，包括 "\n" 字符。
file.readlines([sizenint])	读取所有行并返回列表
file.seek(offset,[whence])	移动文件读取指针到指定位置
file.tell()	返回文件当前位置
file.truncate([size])	从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除
file.write(str)	将字符串写入文件, 并返回写入字符的长度
file.writelines(sequence)	向文件写入一个字符串列表，如果需要换行则要自己加入每行的换行符

文件操作常用函数

file.read()

file = open('text.txt','r+')

print(file.read())
# 输出文件所有内容:
# www.taobao.com
# www.jd.com
# www.baidu.com

file.close()

file = open('text.txt','r+')

print(file.read(10))
#输出10个字节的文件内容:www.taobao

file.close()

file.readline()

file = open('text.txt','r+')

print(file.readline())
# 输出文件一行内容:
# www.taobao.com

file.readlines()

file = open('text.txt','r+')

print(file.readlines())
#输出含有文件所有内容的列表(包含换行符):
['www.taobao.com\n', 'www.jd.com\n', 'www.baidu.com\n', '\n']

file.close

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件

with open('result.txt','w+') as f:
    f.write("this is testing")

print(f.closed) #判断文件是否关闭，输出True

file.seek(offset,[whence])

• offset: 移动偏移的字节数

• whence: 默认值为0; 0表示从文件开头开始, 1表示从当前位置开始, 2表示从文件末尾开始

f = open('workfile', 'rb+')
f.write("0123456789abcdef")
f.seek(5) #移动至第六个字节
print(f.read(1)) #输出5

f.seek(-3,2) #移动到文件倒数第三个字节
print(f.read(1)) #输出'd'

file.write(str)

• str: 要写入的字符串

# 打开文件
fo = open("test.txt", "r+")
print ("文件名: ", fo.name)

str = "6:www.test.com"
# 在文件末尾写入一行
fo.seek(0,2)  #移动至文件内容末尾
line = fo.write(str )

# 读取文件所有内容
fo.seek(0,0) #移动至文件内容开头
for index in range(6):
    line = next(fo) 
    print ("文件行号 %d - %s" % (index, line))

# 关闭文件
fo.close()

file.writelines(seq)

• seq: 要写入文件的字符串序列

fo = open("test.txt", "w")
print ("文件名为: ", fo.name)
seq = ["Henry", "Tom"]
fo.writelines( seq )

# 关闭文件
fo.close()

面向对象

简介

Python从设计之初就已经是一门面向对象的语言, 面向对象编程三大特性如下:

• 封装: 隐藏实现细节，使代码模块化

• 继承: 扩展已存在的类来实现代码重用，避免重复编写相同的代码

• 多态: 封装和继承的目的都是为了实现代码重用， 而多态是为了实现接口重用，使得类在继承和派生的时候能够保证任何一个类的实例都能正确调用约定好的属性和方法

术语

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

• **方法：**类中定义的函数。

• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。

• **数据成员：**类变量或者实例变量用于处理类及其实例对象的相关的数据。

• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖，也称为方法的重写。

• **局部变量：**定义在方法中的变量，只作用于当前实例的类。

• **实例变量：**在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

• **继承：**即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

• **实例化：**创建一个类的实例，类的具体对象。

• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

对象的属性

在python中, 每个对象都有三个属性：

• ID: 对象的地址, ID相同则表示同一对象

• 类型(type)

• 数值

类的定义

类是一种抽象数据类型，是对现实世界的一类数据及其操作的封装

类实例化后，可以使用其属性，创建一个类后，可以通过类名访问其类属性

如下所示, 定义一个含有三个属性的person类, 分别是ID(身份证号)、name(姓名)、nationality(国籍)

其中所有人的身份证号码都是不一样的，且不允许直接通过类或实例来访问或随意修改

import uuid
 
 
class Person:
    nationality = "China"
 
	#类的初始化
    def __init__(self, name):  
        self.name = name
        self.__id = str(uuid.uuid1())
 
    def hello(self):
        print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))

类的实例化

import uuid

class Person:
    nationality = "China"

    def __init__(self, name):
        self.name = name
        self.__id = str(uuid.uuid1())

    def hello(self):
        print("Hello, I am %s, I come from %s, My ID is %s" % (self.name, self.nationality, self.__id))


user = Person('henry')  #创建一个类实例化对象user
user.hello() #输出Hello, I am henry, I come from China, My ID is cea8b568-4f53-11ed-a7de-00e04c8c73bb

类成员的可见性

Python中默认所有的成员都是公有成员，但私有成员是以两个下划线开头的名字表示私有成员，私有成员不允许直接访问，只能通过内部方法进行访问，私有成员也不允许被继承

Python中通过在类变量、实例变量、类方法、实例方法前加__前缀，可以将其对外进行隐藏，变为类的私有变量或函数

由于Python中内置变量或函数使用__作为前后缀，因此不推荐私有的变量或函数在前后缀都用__，而是只在前缀用__

Python类维护了一个用于保存类的数据的字典，字典内部Python将私有成员改名为_ClassName__variable，因此在类外通过访问私有变量新的名称可以访问相应的私有变量, 如下代码所示:

import uuid


class Person(object):
    nationality = "China"

    def __init__(self, name):
        self.name = name
        self.__id = str(uuid.uuid1())

    def hello(self):
        print("Hello, I am %s, I come from %s, My ID is %s" % (self.name, self.nationality, self.__id))


if __name__ == "__main__":
    bauer = Person("Bauer")
    print(bauer.__dict__) #输出存放私有成员的字典
    print(bauer._Person__id) #输出该对象的person类的ID


# 输入如下:
# {'name': 'Bauer', '_Person__id': 'ed496846-94c7-11e9-80c4-5ce0c5e8bcf0'}
# ed496846-94c7-11e9-80c4-5ce0c5e8bcf0

类的属性

直接定义在class下的属性是叫公有属性或类属性，类属性是类的所有实例对象共同所有的

类属性可以使用ClassName.VariableName访问，在实例方法内部也可以使用self.VariableName进行访问

import uuid

class Person(object):
    nationality = "China"

    def __init__(self, name):
        self.name = name
        self.__id = str(uuid.uuid1())