字符编码转换
函数
#声明文件编码,格式如下:
#-*- coding:utf-8 -*-
注意此处只是声明了文件编码格式,python的默认编码还是unicode
字符编码转换:
import sys
print(sys.getdefaultencoding()) #查询当前编码
s = "你好" #python默认编码为unicode
print(s.encode("utf-8")) #转换为utf-8编码
t = b'\xe4\xbd\xa0\xe5\xa5\xbd' #二进制转换为str
print(t.decode())
>>>>
utf-8 #查询当前编码为utf-8
b'\xe4\xbd\xa0\xe5\xa5\xbd' #unicode 转换为utf-8 在python3中默认打印格式为二进制格式
你好 #转换为str
print(s.encode("utf-8").decode("utf-8").encode("gbk")) #注意encode的时候括号里写要转成的编码,decode的时候括号里写原始文件的编码!
>>>>>b'\xc4\xe3\xba\xc3'
函数
定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可
特性:
1.减少重复代码
2.使程序变的可扩展
3.使程序变得易维护
函数的语法结构:
1 def greet_user(username): #定义函数名
2 print("Hello!",username.title(),"!") #函数体
3 greet_user("ww")
函数的形参与实参
1 def describe_pet(pet_name,animal_type="dog"): #指定默认值的形参要放在最后面,不然会报错
2 """显示宠物信息"""
3 print("I have a %s.\nMy %s 's name is %s.\n"%(animal_type,animal_type,pet_name))
4 describe_pet("hamster","harry") #位置实参位置要与形参一致,此处没有,会变成 harry是宠物类型,hamster变成了宠物名字
5 describe_pet(pet_name="ww",animal_type="cat") #关键字实参
6 describe_pet(pet_name="ww") #当形参有默认值时,若不给形参传递实参,则默认输出默认值
向函数传递实参的方式很多,可使用位置实参,这要求实参的顺序与形参的顺序相同;也可使用关键字实参,其
中每个实参都由变量名和值组成;还可使用列表和字典。
函数describe_pet()还是原来那样,但调用这个函数时,我们向Python明确地指出了各个实参对应的形参。
关键字实参的顺序无关紧要,因为Python知道各个值该存储到哪个形参中。
使用关键字实参时,若关键字和位置参数混合使用,关键字参数一定要放在位置参数后面
函数的返回值(关于return的理解,知乎这个回答很形象 https://www.zhihu.com/question/23765556/answer/25635772)
1 def get_formatted_name(first_name,last_name,middle_name=''): #此处给形参【middle_name】设置了默认值,让实参变得可选
2 """打印完整姓名"""
3 if middle_name: #若middle_name不为空,则只都打印
4 full_name = first_name+' '+middle_name+' '+last_name
5 else: #middle_name为空,则只打印 firstname和lastname
6 full_name = first_name+' '+last_name
7 return full_name.title()
8 musician = get_formatted_name('jimi','alex','cily')
9 musician2 = get_formatted_name('jimi','alex',)
10 print(musician,'\n',musician2)
1 def bulid_person(first_name,last_name,age=''): #函数返回值为字典
2 """返回个人信息到字典中"""
3 person = {'first':first_name,'last':last_name}
4 if age:
5 person['age'] = age
6 return person
7 jimi = bulid_person('jimi','alex','22')
8 print(jimi)
1 #函数和while循环结合
2 def get_formatted_name(firstname,lastname):
3 full_name = firstname+' '+lastname
4 return full_name.title()
5 6 while True:
7 f_name = input("input your firstname:") #函数的实参,可通过inpu函数进行输入
8 if f_name == "q":
9 break
10 l_name = input("input your lastname:")
11 if l_name == "q":
12 break
13 musician = get_formatted_name(f_name, l_name)
14 print(musician)
1 def print_models(unprinted_design,completed_models): #函数与列表
2 """模拟打印每个设计,直到没有未打印的设计为止
3 打印每个设计后,都将其移到列表completed_models中"""
4 while unprinted_design:
5 current_design = unprinted_design.pop()
6 completed_models.append(current_design)
7 print("Printing model:" + current_design)
8
9 def show_completed_models(completed_models):
10 """显示打印好的模型"""
11 print("The fllowing models have been printed: ")
12 for model_completed in completed_models:
13 print(model_completed)
14
15
16 print_design = ['1','2','3','4']
17 complete_design = []
18
19 print_models(print_design,complete_design)
20 show_completed_models(complete_design)
def test1():
print("in the test1")
return 1,"gkx",["cc","dd"],{"zoo":"chimpanzee"} #return可以多个值,包括可以return函数
def test2():
print("in the test2")
return test1(),"aaaaaaaaaa" #return函数
y = test1()
x = test2()
print(x,y)
>>>>>
in the test1
in the test2
in the test1 #test2()在returnt test1 的时候,会运行一遍test1() 并返回其return值
((1, 'gkx', ['cc', 'dd'], {'zoo': 'chimpanzee'}), 'aaaaaaaaaa') (1, 'gkx', ['cc', 'dd'], {'zoo': 'chimpanzee'})
return:
返回值数=0:返回None
返回值数=1:返回object,python返回值时对象
返回值数>1,返回tuple
定义参数组:非固定参数
def test(*args): #接收多个位置参数,转换为元组
print(args)
test(1,2,3,4,5,6,6) #实参传入的时候,数量可以不固定,
test(*[1,2,3,4,5]) #第二种传值方法
>>>>>
(1, 2, 3, 4, 5, 6, 6) #打印的时候以元组表示
(1, 2, 3, 4, 5)
def test2(**kwargs): #接收多个关键字参数,转换为字典
print(kwargs)
test2(name='gkx',age='99',sex='male') #也有两种传值方式
test2(**{'name':'gkx','age':'99'})
>>>>>
{'name': 'gkx', 'age': '99', 'sex': 'male'}
{'name': 'gkx', 'age': '99'}
非固定参数的传参方式,也可以如下所示
1 def f(*args,**kwargs): #位置参数、默认参数、**kwargs三者的顺序必须是位置参数、默认参数、**kwargs,不然就会报错:
2 print(args,kwargs)
3
4 f(age=1,name='ddd')
5
6 def foo(*args,**kwargs):
7 print(kwargs)
8 print(args)
9 foo(**{"a":2,"b":3,"c":4,"d":5}) # *(1,2,3)解释器将自动进行解包然后传递给多个单变量参数(参数个数要对应相等)。序列解包要在关键参数和 **参数 之前进行处理
10 foo(*[1,2,3,4,5])
11
>>> msg = {'num':1,'num2':2}
>>> def test(msg): #当设置形参的时候没有用 **msg,可以直接用字典传参
print(msg['num']+msg['num2'])
>>> test(msg)
3
当设置形参的时候没有用 **msg,可以直接用字典传参
12 》》》》
13 () {'age': 1, 'name': 'ddd'}
14 {'a': 2, 'b': 3, 'c': 4, 'd': 5}
15 ()
16 {}
17 (1, 2, 3, 4, 5)
>>> test(1,2,1,c=3)
1 2 (1,) {'c': 3}
>>> def test(x,y=0,*args,**kwargs): #args可以放在默认参数的前面或者后面,不过要注意传参的方式
print('x是:',x)
print('y是:',y)
print('args是:',args)
print('kwargs是',kwargs)
>>> test(1,2,3,a=5)
x是: 1
y是: 2
args是: (3,)
kwargs是 {'a': 5}
>>> def test(x,*args,y=0,**kwargs):
print('x是:',x)
print('y是:',y)
print('args是:',args)
print('kwargs是',kwargs)
>>> test(1,2,3,a=5)
x是: 1
y是: 0
args是: (2, 3) #如果args放在默认参数前,需要指定默认参数的值,不然会被传入args
kwargs是 {'a': 5}
>>> test(1,2,y=3,a=5)
x是: 1
y是: 3
args是: (2,)
kwargs是 {'a': 5}
>>>
位置参数,参数组的顺序
小结:
def test1(*args): 接收多个位置参数,转换为元组 ,【接收不到关键字参数】
def test2(**kwargs) 接收多个关键字参数,转换为元组
若混合使用,则 位置参数最前,关键字参数居中,参数组一定放最后。