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.使程序变得易维护

函数的语法结构：

 def greet_user(username):                   #定义函数名
     print("Hello!",username.title(),"!")    #函数体
 greet_user("ww")

函数的形参与实参

 def describe_pet(pet_name,animal_type="dog"): #指定默认值的形参要放在最后面，不然会报错
     """显示宠物信息"""
     print("I have a %s.\nMy %s 's name is %s.\n"%(animal_type,animal_type,pet_name))
 describe_pet("hamster","harry")               #位置实参位置要与形参一致，此处没有，会变成 harry是宠物类型，hamster变成了宠物名字
 describe_pet(pet_name="ww",animal_type="cat") #关键字实参
 describe_pet(pet_name="ww")                   #当形参有默认值时，若不给形参传递实参，则默认输出默认值

向函数传递实参的方式很多，可使用位置实参，这要求实参的顺序与形参的顺序相同；也可使用关键字实参，其
中每个实参都由变量名和值组成；还可使用列表和字典。
函数describe_pet()还是原来那样，但调用这个函数时，我们向Python明确地指出了各个实参对应的形参。
关键字实参的顺序无关紧要，因为Python知道各个值该存储到哪个形参中。
使用关键字实参时，若关键字和位置参数混合使用，关键字参数一定要放在位置参数后面

函数的返回值（关于return的理解，知乎这个回答很形象 https://www.zhihu.com/question/23765556/answer/25635772）

 def get_formatted_name(first_name,last_name,middle_name=''):   #此处给形参【middle_name】设置了默认值，让实参变得可选
     """打印完整姓名"""
     if middle_name:                                            #若middle_name不为空，则只都打印
         full_name = first_name+' '+middle_name+' '+last_name
     else:　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #middle_name为空，则只打印 firstname和lastname
         full_name = first_name+' '+last_name
     return  full_name.title()
 musician = get_formatted_name('jimi','alex','cily')
 musician2 = get_formatted_name('jimi','alex',)
 print(musician,'\n',musician2)

 def bulid_person(first_name,last_name,age=''):   #函数返回值为字典
     """返回个人信息到字典中"""
     person = {'first':first_name,'last':last_name}
     if age:
         person['age'] = age
     return  person
 jimi = bulid_person('jimi','alex','')
 print(jimi)

 #函数和while循环结合
 def get_formatted_name(firstname,lastname):
     full_name = firstname+' '+lastname
     return  full_name.title()
  while True:
     f_name = input("input your firstname:")     #函数的实参，可通过inpu函数进行输入
     if f_name == "q":
         break
     l_name = input("input your lastname:")
     if l_name == "q":
         break
     musician = get_formatted_name(f_name, l_name)
     print(musician)

 def print_models(unprinted_design,completed_models):   #函数与列表
     """模拟打印每个设计，直到没有未打印的设计为止
     打印每个设计后，都将其移到列表completed_models中"""
     while unprinted_design:
         current_design = unprinted_design.pop()
         completed_models.append(current_design)
         print("Printing model:" + current_design)

 def show_completed_models(completed_models):
     """显示打印好的模型"""
     print("The fllowing models have been printed: ")
     for model_completed in completed_models:
         print(model_completed)

 print_design = ['','','','']
 complete_design = []

 print_models(print_design,complete_design)
 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='',sex='male')  #也有两种传值方式
test2(**{'name':'gkx','age':''})

>>>>>
{'name': 'gkx', 'age': '', 'sex': 'male'}
{'name': 'gkx', 'age': ''}

非固定参数的传参方式，也可以如下所示

 def f(*args,**kwargs): #位置参数、默认参数、**kwargs三者的顺序必须是位置参数、默认参数、**kwargs，不然就会报错：
     print(args,kwargs)

 f(age=1,name='ddd')

 def foo(*args,**kwargs):
     print(kwargs)
     print(args)
 9 foo(**{"a":2,"b":3,"c":4,"d":5})   # *（1,2,3）解释器将自动进行解包然后传递给多个单变量参数（参数个数要对应相等）。序列解包要在关键参数和  **参数 之前进行处理
10 foo(*[1,2,3,4,5])
 

>>> msg = {'num':1,'num2':2}
>>> def test(msg):  #当设置形参的时候没有用 **msg，可以直接用字典传参
    print(msg['num']+msg['num2'])

>>> test(msg)
3

当设置形参的时候没有用 **msg，可以直接用字典传参

 》》》》
 () {'age': 1, 'name': 'ddd'}
 {'a': 2, 'b': 3, 'c': 4, 'd': 5}
 ()
 {}
 (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)    接收多个关键字参数，转换为元组

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