Python—字符编码转换、函数基本操作

字符编码转换

函数

 

 

#声明文件编码，格式如下：

#-*- 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)    接收多个关键字参数，转换为元组

 若混合使用，则  位置参数最前，关键字参数居中，参数组一定放最后。

 

转载于:https://www.cnblogs.com/gkx0731/p/9439618.html