phyton的函数的学习

在本文中，你将学习编写函数。函数是带名字的代码块，用于完成具体的工作。
要执行函数定义的特定任务，可调用该函数。需要在程序中多次执行同一项任务时，你无需反复编写完成该任务的代码，而只需调用执行该任务的函数，让Python运行
其中的代码。你将发现，通过使用函数，程序的编写、阅读、测试和修复都将更容易。

定义函数

def 函数名（参数列表）:
函数体
return 返回值
#调用函数
函数名（具有实际值的参数列表
而函数名的定义：
1：函数名只能包含字母、数字和下划线。函数可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
2：函数名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greetingmessage会引发错误。
3：不要将Python关键字和内置函数名用作函数名，即不要使用Python保留用于特殊用途的单词，如print。
4：函数名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
5：慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。
注意：
1 定义的函数与调用的函数名一致。
2 “计算机一丝不苟，但不关心拼写是否正确。因此，创建函数名和编写代码时，你无需考虑英语中的拼写和语法规则。”
简单的函数，没有参数。

def name():print("many peoples name:")
name()

many peoples name：

向函数传递信息：加入参数

def greet_user(name1,name2):"""问好语句"""print("Good morning Mr."+name1.title()+"!")print("Good eveing  Ms."+name2.title()+"!")
greet_user("pitter","mo ruiya")

Good morning Mr.Pitter!
Good eveing Ms.Mo Ruiya!

`**实参和形参`

前面我们定义函数greet_user函数并且向函数传递name1，name2两个参数，而这时的的参数为形参。
但是在调用函数greet_user定义参数pitter，mo ruiya两个参数是实参。
即在函数定义时的参数是形参而在函数调用时定义的参数是实参。
并且形掺和实参是一一对应的。

传递任意数量的实参

有时候，你预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。
def 函数名(*形参）：
这样一个形参就可以接受函数传递的数个实参。

def textbook(*kinds):for kind in kinds:print(kind)
textbook('语文','英语','数学')
textbook('\n思想品德')

语文
英语
数学

思想品德

传递实参

鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。向函数传递实参的方式很多，可使用位置实参，这要求实参的顺序与形参的顺序相同；也可使用关键
字实参，其中每个实参都由变量名和值组成；还可使用列表和字典。下面来依次介绍这些方式。
位置实参
位置实参：实参的位置与形参的位置一一对应。

def greet_user(name1,name2,name3,name4):"""问好语句"""print("Good morning Mr."+name1.title()+"!")print("Good eveing  Ms."+name2.upper()+"!")print("Good afternoon Mr."+name3.lower()+'.')print("Hello Ms."+name4.title()+":")
greet_user("pitter","mo ruiya","liwei","li hong")

Good morning Mr.Pitter!
Good eveing Ms.MO RUIYA!
Good afternoon Mr.liwei.
Hello Ms.Li Hong:

调用函数多次
你可以根据需要调用函数任意次。

def greet_user(name1,name2,name3,name4):"""问好语句"""print("Good morning Mr."+name1.title()+"!")print("Good eveing  Ms."+name2.upper()+"!")print("Good afternoon Mr."+name3.lower()+'.')print("Hello Ms."+name4.title()+":")
greet_user("pitter","mo ruiya","liwei","li hong")
print('\t第二次调用函数')
greet_user("mis","li hau","zhang san","xiao hang")
........

D:\PycharmProjects\111\venv\Scripts\python.exe “D:/PycharmProjects/111/take down.py”
Good morning Mr.Pitter!
Good eveing Ms.MO RUIYA!
Good afternoon Mr.liwei.
Hello Ms.Li Hong:
第二次调用函数
Good morning Mr.Mis!
Good eveing Ms.LI HAU!
Good afternoon Mr.zhang san.
Hello Ms.Xiao Hang:

位置实参的顺序很重要

使用位置实参来调用函数时，如果实参的顺序不正确，结果可能出乎意料：

def greet_user(name1,name2,):print("Good morning Mr." + name1.title() + "!")print("Good eveing  Ms." + name2.title() + "!")
greet_user("mo ruiya","pitter")

Good morning Mr.Mo Ruiya!
Good eveing Ms.Pitter!

在上面代码中mo ruiya与pitter的位置错误，导致问好时Mr.Mo Ruiya，Ms.pitter。出了笑话。

关键字实参

关键字实参是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆（不会得到名为Mr.Mo Ruiya和Ms.pitter这样的结果）。关键字实参让
你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

def greet_user(name1,name2,):print("Good morning Mr." + name1.title() + "!")print("Good eveing  Ms." + name2.title() + "!")
greet_user(name2="mo ruiya",name1="pitter")

Good morning Mr.Pitter!
Good eveing Ms.Mo Ruiya!

注意使用关键字实参时，务必准确地指定函数定义中的形参名。

结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。在Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

def textbook(kind1,kind2,*kinds):print(kind1)print(kind2)for kind in kinds:print("\n"+kind)
textbook('语文','英语','数学','科学','物理','化学')

前两个是位置参，后面的任意参

语文
英语

数学

科学

物理

化学

使用任意数量的关键字实参

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接
受多少。

def build_profile(first, last, **user_info):"""创建一个字典，其中包含我们知道的有关用户的一切"""profile = {}profile['first_name'] = firstprofile['last_name'] = lastfor key, value in user_info.items():profile[key] = valuereturn profile
user_profile = build_profile('albert', 'einstein',location='princeton',field='physics')
print(user_profile)

{‘first_name’: ‘albert’, ‘last_name’: ‘einstein’, ‘location’: ‘princeton’, ‘field’: ‘physics’}

>def 函数名(参数名）这样就创建空字典，并将收到的所有名称—值对都封装到这个字典中。在这个函数中，可以像访问其他字典那样访问参数中的名称—值对

默认值

编写函数时，可给每个形参指定默认值。在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数
调用中省略相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用

def fruits(fruit1,fruit2,fruit3="watermelon"):"""水果的类型"""print("我想要水果的种类："+fruit1 +"\t"+fruit2+"\t" +fruit3)
fruits("banana","grape")
fruits("yangtao","mango","apple")

我想要水果的种类：banana grape watermelon
我想要水果的种类：yangtao mango apple

**** 让实参变成可选的****
让实参可选是在函数定义是给形参提供个默认值。
当在调用函数时如果不给这个形参提供实参，则这个形参就会使用默认值，返给函数调用。
等效的函数调用
鉴于可混合使用位置实参、关键字实参和默认值，通常有多种等效的函数调用方式。

def fruits(fruit1,fruit2,fruit3="watermelon"):"""水果的类型"""print("我想要水果的种类："+fruit1 +"\t"+fruit2+"\t" +fruit3)
fruits("banana","grape")
fruits(fruit2="yangtao",fruit1="mango",)
fruits("banana","yangtao")

我想要水果的种类：banana grape watermelon
我想要水果的种类：mango yangtao watermelon
我想要水果的种类：banana yangtao watermelon

注意：混合使用位置参，关键字参，默认参时。位置参不可以与关键字参混合但可以与默认参混合，关键字参可以默认参混合。

返回值

函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。在函数中，可使用return 语句将值返回到调用函数的代码行。返回值让你能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。函数return返回的是你想要的得到的结果例如
return返回的正方形的面积

def square(length):"""求正方形的面积"""are=length**2return are
are=square(2)
print(are)

4

return返回的是正方形的边长

def square(length):"""求正方形的面积"""length**2return length
length=square(2)
print(length)

2

返回字典

函数可返回任何类型的键，包括列表和字典等较复杂的数据结构。

def pet_animal(kind1,kind2,kind3,kind4):"""动物的种类"""animas={kind1:"cat,dag,fish",kind2:"cuckold,crocodile,boa",kind3:"flower,grass,tree",kind4:"game,story,computer"}return animas
animals=pet_animal('animal',"rare animal","plant","hobby")
print(animals)

{‘animal’: ‘cat,dag,fish’, ‘rare animal’: ‘cuckold,crocodile,boa’, ‘plant’: ‘flower,grass,tree’, ‘hobby’: ‘game,story,computer’}

也可以返回的是值

def pet_animal(kind1,kind2,kind3,kind4):"""动物的种类"""animas={'animal':kind1,"rare animal":kind2,"plant":kind3,"hobby":kind4}return animas
animals=pet_animal("dag,cat,pig"," ‘cuckold,crocodile,boa","flower,grass,tree","game,story,computer")
print(animals

{‘animal’: ‘dag,cat,pig’, ‘rare animal’: ’ ‘cuckold,crocodile,boa’, ‘plant’: ‘flower,grass,tree’, ‘hobby’: ‘game,story,computer’}

结合使用函数和while 循环

def  people_information(address="China",year="20",sex="nan",height=" 140"):"""搜集个人信息"""people_informations={"address":address,"year":year,"sex":sex,"height":height}return people_informations
while True:print("请填入你的信息：")print("如果不想填入你的信息请填入:q")dizhi=input("请输入你的地址：")if dizhi=='q':continuenianling=input("请输入你的年龄：")if nianling=="q":breakxingbei=input("请输入你的性别：")if xingbei=="q":continueshengao=input("请输入你的升高：")if shengao=="q":break
people_informations=people_information(dizhi,nianling,xingbei,shengao)
print(people_informations)

请填入你的信息：
如果不想填入你的信息请填入:q
请输入你的地址：

用while循环收集信息。

传递列表

你经常会发现，向函数传递列表很有用，这种列表包含的可能是名字、数字或更复杂的对象（如字典）。将列表传递给函数后，函数就能直接访问其内容。下面使用函数来提高
处理列表的效率。

def greet_users(names):"""向列表中的每位用户都发出简单的问候"""for name in names:msg = "Hello, " + name.title() + "!"print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)

Hello, Hannah!
Hello, Ty!
Hello, Margot!

在函数中修改列表

将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。

def student_timetable(Chinese,English,math,):"""学生的课表"""student_timetables={'kind1':Chinese,'kind2':English,'kind3':math}for chinese in student_timetables['kind1']:print("汉语课："+chinese)for english in student_timetables['kind2']:print("英语课："+english)for Math in student_timetables['kind3']:print("数学课："+Math)
china=["星期一8.00————10.20","星期二10.30——12.00","星期五4.00——6.00"]
Englise=["星期二4.00——6.00","星期三8.00——10.00","星期五2.00——3.00"]
maths=["星期二3.00——4.00","星期三2.00——4.30","星期四10.00——12.00"]
student_timetable(Chinese=china,math=maths,English=Englise)

汉语课：星期一8.00————10.20
汉语课：星期二10.30——12.00
汉语课：星期五4.00——6.00
英语课：星期二4.00——6.00
英语课：星期三8.00——10.00
英语课：星期五2.00——3.00
数学课：星期二3.00——4.00
数学课：星期三2.00——4.30
数学课：星期四10.00——12.00

这样课表要修改了，只把列表修改一下。
编写函数与不变函数的代码相比，编写函数的程序更容易扩展和维护。列入后面还需要这样的程序只需要调用函数名就可以了。不需要再编写一次。而且修改函数比修改不编写函数程序方便快捷。————这就是编写函数的好处，
在编写函数时，我们必须要有每个只应负责一部分工作意识，如果这样编写函数会让你的程序更容易让别人读懂。

禁止函数修改列表

在编写函数时会因为函数的需要会对提供的列表中的元素进行修改，但是当我们想要函数，也想要保留列表的元素不被需改。那我们该怎半。
利用列表的切片。

def student_timetable(Chinese,English,math,):"""学生的课表"""student_timetables={'kind1':Chinese,'kind2':English,'kind3':math}for chinese in student_timetables['kind1']:print("汉语课："+chinese)for english in student_timetables['kind2']:print("英语课："+english)for Math in student_timetables['kind3']:print("数学课："+Math)
china=["星期一8.00————10.20","星期二10.30——12.00","星期五4.00——6.00"]
Englise=["星期二4.00——6.00","星期三8.00——10.00","星期五2.00——3.00"]
maths=["星期二3.00——4.00","星期三2.00——4.30","星期四10.00——12.00"]
student_timetable(Chinese=china[:],math=maths[:],English=Englise[:])

汉语课：星期一8.00————10.20
汉语课：星期二10.30——12.00
汉语课：星期五4.00——6.00
英语课：星期二4.00——6.00
英语课：星期三8.00——10.00
英语课：星期五2.00——3.00
数学课：星期二3.00——4.00
数学课：星期三2.00——4.30
数学课：星期四10.00——12.00

列表的[:]
就是把列表的元素复制一遍。然后把列表的副本传递给函数，这样就不会函数把列表的元素修改。
虽然向函数传递列表的副本可保留原始列表的内容，但除非有充分的理由需要传递副本，否则还是应该将原始列表传递给函数，因为让函数使用现成列表可避免花时间和内存创
建副本，从而提高效率，在处理大型列表时尤其如此。

将函数存储在模块中

函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，
再将模块导入到主程序中。import 语句允许在当前运行的程序文件中使用模块中的代码。
通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。这还能让你在众多不同的程序中重用函数。将函数存储在独立文件中后，可与其他程
序员共享这些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库。

导入整个模块

要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。
在phyton中文件的名称是：文件名.py
导入整个模块只需要 import 文件名，
这样就可以调用文件内的函数例如

def M_dormitory(**kind):"""动物寝室的爱好"""dormitory={}for key ,value in kind.items():dormitory[key]=valuereturn dormitory
names=['dog','cat','rabbit']
hobbys=['bone','mouse','carrot']
for name in names:for hobby in hobbys:M_dormitory(name=hobby

输出的是空白

导入特定的函数

你还可以导入模块中的特定函数，这种导入方法的语法如下：

from module_name import function_name

通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：

from module_name import function_0, function_1, function_2

使用as 给函数指定别名

如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名 ——函数的另一个名称，类似于外号。要给函数指定这种特殊外
号，需要在导入它时这样做。
下面给函数make_pizza() 指定了别名mp() 。这是在import 语句中使用make_pizza as mp 实现的，关键字as 将函数重命名为你提供的别名：

from pizza import make_pizza as mp
mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

上面的import 语句将函数make_pizza() 重命名为mp() ；在这个程序中，每当需要调用make_pizza() 时，都可简写成mp() ，而Python将运行make_pizza() 中的代
码，这可避免与这个程序可能包含的函数make_pizza() 混淆。
指定别名的通用语法如下：

使用as 给模块指定别名

你还可以给模块指定别名。通过给模块指定简短的别名（如给模块pizza 指定别名p ），让你能够更轻松地调用模块中的函数。相比于pizza.make_pizza() ，p.make_pizza() 更为简洁：

import pizza as p
p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

上述import 语句给模块pizza 指定了别名p ，但该模块中所有函数的名称都没变。调用函数make_pizza() 时，可编写代码p.make_pizza() 而不
是pizza.make_pizza() ，这样不仅能使代码更简洁，还可以让你不再关注模块名，而专注于描述性的函数名。这些函数名明确地指出了函数的功能，对理解代码而言，它们
比模块名更重要。

给模块指定别名的通用语法如下：

import module_name as mn

导入模块中的所有函数

使用星号（* ）运算符可让Python导入模块中的所有函数：

from pizza import *
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese'

port 语句中的星号让Python将模块pizza 中的每个函数都复制到这个程序文件中。由于导入了每个函数，可通过名称来调用每个函数，而无需使用句点表示法。然而，使用
并非自己编写的大型模块时，最好不要采用这种导入方法：如果模块中有函数的名称与你的项目中使用的名称相同，可能导致意想不到的结果：Python可能遇到多个名称相同的函
数或变量，进而覆盖函数，而不是分别导入所有的函数。
最佳的做法是，要么只导入你需要使用的函数，要么导入整个模块并使用句点表示法。这能让代码更清晰，更容易阅读和理解。这里之所以介绍这种导入方法，只是想让你在阅
读别人编写的代码时，如果遇到类似于下面的import 语句，能够理解它们：

from module_name import *

编写函数的注意事项

一
给函数命名时，应给函数指定描述性的名称，描述性的名称可以帮助你和别人明白这个函数的功能或作用。如函数title，作用就是把字符串的首字母大写，title的意思是标题。这样函数名与函数的作用相对应。
二
在给模块命名时也应遵循”给函数命名“的约定。
三
每个函数都应包含简要地阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字符串格式。文档良好的函数让其他程序员只需阅读文档字符串中的描述就能够使用它：他们完全可以相信代码如描述的那样运行；只要知道函数的名称、需要的实参以及返回值的类型，就能在自己的程序中使用它。
四
给形参指定默认值时，等号两边不要有空格：

def names(kind1=' makabaka ',kind2=' jeirui '}

五
对于函数调用中的关键字实参，也应遵循这种约定：

names(' xijei ',' manei ')

六
建议代码行的长度不要超过79字符，这样只要编辑器窗口适中，就能看到整行代码。如果形参很多，导致函数定义的长度超过了
79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开来。
大多数编辑器都会自动对齐后续参数列表行，使其缩进程度与你给第一个参数列表行指定的缩进程度相同。
七
如果程序或模块包含多个函数，可使用两个空行将相邻的函数分开，这样将更容易知道前一个函数在什么地方结束，下一个函数从什么地方开始。
八
所有的import 语句都应放在文件开头，唯一例外的情形是，在文件开头使用了注释来描述整个程序。

类

类表示你编写表示现实世界的事物和情景，并基于这些类创建对象。
编写类时，你定义一大类对象都有的通用行为。每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。使用面向对象编程可模拟现实情景。
根据类来创建对象被称为实例化。

创建和使用类

使用类几乎可以模拟任何东西。下面来编写一个表示国宝（大熊猫）的简单类 Panda——它表示不是特定的panda，而是任何panda。对于大多数大熊猫来说，它会有自己的年龄，名字，爱吃竹子，爱睡觉，会上树，会撒娇。由上六项内容可知道，大熊猫有两个基本信息，两个爱好，两个基本动作。我们的panda类将包含他们。这个类让phyton知道如何创建panda的对象。编写这个类之后，我们将使用它来创建特定大熊猫的实例。
创建大熊猫的类
根据Panda类创建的每个实例都将存储
名字name年龄year，
爱好（hobby）睡觉sleep，吃竹子（eat __barboo），
能力（ability）上树（on__the__tree），撒娇（coquetry）。

class Panda():"""一次模拟大熊猫"""def __init__(self,name,year):"""初始化属性名字，年龄"""self.name=nameself.year=yeardef sleep(self):"""一次模拟大熊猫的睡觉"""print(self.name.title()+" is now sleep")def eat__bamboo(self):print(self.name.title()+" is now eat__bamboo")"""一次模拟大熊猫吃竹子"""def on__the__tree(self):"""模拟一次大熊猫在树上"""print(self.name.title()+" is now on__the__tree")def coquetry(self):"""模拟一次大熊猫撒娇"""print(self.name.title()+" is now coquetry")
china_panda= Panda('huan huan',3)
print("panda's name is "+ china_panda.name.title()+ "!")
print("panda's year is "+ str(china_panda.year)+ " age.")
china_panda.sleep()
china_panda.eat__bamboo()
china_panda.on__the__tree()
china_panda.coquetry()

panda’s name is Huan Huan!
panda’s year is 3 age.
Huan Huan is now sleep
Huan Huan is now eat__bamboo
Huan Huan is now on__the__tree
Huan Huan is now coquetry

》在Python中，首字母大写的
名称指的是类。这个类定义中的括号是空的，因为我们要从空白创建这个类。在在第二行代码，我们编写了一个文档字符串，对这个类的功能作了描述。
》方法__init__()
类中的函数称为方法，我们前面学到的关于函数的一切方法都是用就目前而言，唯一的差别在于调用方法的方式。
在第三行代码的方法__init__()是一个特殊的方法，当你根据Panda类创建新实例时，phyton都会运行方法__init__()，这个方法的名称中开头和结尾各有两个下划线：这是一种约定，旨在避免phyton默认方法与普通方法发生冲突。
现在我们将方法__init__()定义成三个形参：self，name，age（在调用方法时我们也要遵守函数调用时，位置参，关键字参，默认参的规则）在方法__init__中self是必不可少，还必须位于其他形掺的前面，
为何在方法__init__定义中包含形掺呢？
因为phyton调用这个方法__init__来创建Panda实例时，将会自动传入实参self，它是在指定实力本身的引用，让实例能够访问类中的属性和方法
我们创建Dog 实例时，Python将调用Panda 类的方法__init__() 。我们将通过实参向Dog() 传递名字和年龄；self 会自动传递，因此我们不需要传递它。每当我们根据Panda 类创建实例时，都只需给最后两个形参（name 和year ）提供值。
在五六行代码处定义的两个变量都有前缀self 。以self 为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。self.name = name 获取存储在形参name 中的值，并将其存储到变量name 中，然后该变量被关联到当前创建的实例。self.year= year的作用与此类似。像这样可通过实例访问的变量称为属性。
Dog 类还定义了另外四个方法：sleep（），eat_bamboo(),on_the_tree()和coquetry（）由于这些方法不需要额外的信息，如名字或年龄，因此它们只有一个形参self 。我们后面将创建的实例能够访问这些方法，换句话说，它们都会睡觉，吃竹子，上树，撒娇。当前，sleep（），eat_bamboo(),on_the_tree()和coquetry（）所做的有限，它们只是打印一条消息，指出小狗正蹲下或打滚。但可以扩展这些方法以模拟。
实际情况：如果这个类包含在一个计算机游戏中，这些方法将包含创建熊猫蹲下和打滚动画效果的代码。如果这个类是用于控制机器大熊猫的，这些方法将引导机器狗做出蹲下和打滚的动作。

根据类创建实例

可将类视为有关如何创建实例的说明。Panda 类是一系列说明，让Python知道如何创建表示特定小狗的实例。
下面来创建一个表示特定大熊猫的实例：

china_panda= Panda('bei bei',5)
print("panda's name is "+ china_panda.name.title()+ "!")
print("panda's year is "+ str(china_panda.year)+ " age.")
china_panda.sleep()
china_panda.eat__bamboo()
china_panda.on__the__tree()
china_panda.coquetry()

panda’s name is Bei Bei!
panda’s year is 5 age.
Bei Bei is now sleep
Bei Bei is now eat__bamboo
Bei Bei is now on__the__tree
Bei Bei is now coquetry

访问属性
要访问实例的属性，可使用句点表示法。我们编写了如下代码来访问china_panda 的属性name 的值：

china_panda.name
china_panda.year

调用方法
根据Panda 类创建实例后，就可以使用句点表示法来调用Panda 类中定义的任何方法。

china_panda.sleep（）
china_panda.eat_bamboo()
'''''''

创建多个实例
可按需求根据类创建任意数量的实例。下面再创建一个名为巴基斯坦的大熊猫（Pakistan_panda）的实例：

在这里插入代码片class Panda():"""一次模拟大熊猫"""def __init__(self,name,year):"""初始化属性名字，年龄"""self.name=nameself.year=yeardef sleep(self):"""一次模拟大熊猫的睡觉"""print(self.name.title()+" is now sleep")def eat__bamboo(self):print(self.name.title()+" is now eat__bamboo")"""一次模拟大熊猫吃竹子"""def on__the__tree(self):"""模拟一次大熊猫在树上"""print(self.name.title()+" is now on__the__tree")def coquetry(self):"""模拟一次大熊猫撒娇"""print(self.name.title()+" is now coquetry")
china_panda= Panda('bei bei',5)
print("panda's name is "+ china_panda.name.title()+ "!")
print("panda's year is "+ str(china_panda.year)+ " age.")
china_panda.sleep()
china_panda.eat__bamboo()
china_panda.on__the__tree()
china_panda.coquetry()
print('\n')
Pakistan_panda=Panda('godzilla',3)
print("panda's name is "+ Pakistan_panda.name.title()+ "!")
print("panda's year is "+ str(Pakistan_panda.year)+ " age.")
Pakistan_panda.sleep()
Pakistan_panda.eat__bamboo()
Pakistan_panda.on__the__tree()
Pakistan_panda.coquetry()

panda’s name is Bei Bei!
panda’s year is 5 age.
Bei Bei is now sleep
Bei Bei is now eat__bamboo
Bei Bei is now on__the__tree
Bei Bei is now coquetry

panda’s name is Godzilla!
panda’s year is 3 age.
Godzilla is now sleep
Godzilla is now eat__bamboo
Godzilla is now on__the__tree
Godzilla is now coquetry

使用类和实例

你可以使用类来模拟现实世界中的很多情景。类编写好后，你的大部分时间都将花在使用根据类创建的实例上。你需要执行的一个重要任务是修改实例的属性。你可以直接修改
实例的属性，也可以编写方法以特定的方式进行修改。
Phone 类
下面来编写一个表示手机的类，它存储了有关手机的功能，还有一个表示时间的方法：

class Phone():"""一次模拟手机"""def __init__(self,call,photograph,chat,Visit_Taobao):"""初始化属性打电话，拍照，聊天，逛淘宝"""self.call=callself.photograph=photographself.chat=chatself.Visit_Taobao=Visit_Taobaoprint("小爱同学,给"+call+"打电话"+".")print("小爱同学，打开"+photograph+"拍照。")print("小爱同学，打开QQ，给"+chat+"发消息！")print("小爱同学，打开淘宝中的那个店铺"+Visit_Taobao+"。")def time(self,year,month,day,time,second):"""一次模拟手机时间"""now=str(year)+"年" +str(month)+"月 " +str(day)\+"天" +str(time)+"时" +str(second)+"秒"print(now)return now
my_phone=Phone('mother','photograph','Donkey_Kong','tu_xian_sheng')
my_phone.time(2021,5,21,13,14)

小爱同学,给mother打电话.
小爱同学，打开photograph拍照。
小爱同学，打开QQ，给Donkey_Kong发消息！
小爱同学，打开淘宝中的那个店铺tu_xian_sheng。
2021年5月 21天13时14秒

在这次模拟手机时，我们借用_init_方法模拟手机的打电话，拍照，聊天，逛淘宝，等属性。
并且我i我们定义时间time方法来表达时间。

给属性指定默认值

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。在有些情况下，如设置默认值时，在方法__init__() 内指定这种初始值是可行的；如果你对某个属性这样做了，就无需包含为它提供初始值的形参。


```python
class Book():"""一次模拟借书"""def __init__(self,book_name,book_value,A_book_borrower=''):"""定义这本书的名字，价值"""self.book_name=book_nameself.book_value=book_valueself.A_book_borrower=A_book_borrower"""现在我们定义借书人为空字符"""book = "书的名字：" + book_name + "\n书的价值:" + str(book_value) +\"\n借书人的名字："+A_book_borrowerprint(book)def book_borrower_time(self,):"""一次模拟借书时间"""times=input("请输入：你的借书时间：")LI='请输入：你的借书时间：'+str(times)print(LI)return LIdef The_book(self):"""一次模拟还书时间"""still_book=input("请输入：你的还书时间：")max="借书时间："+str(still_book)print(max)return maxborrowed_book=Book('谁动了我的奶酪',20,'小强强')
borrowed_book.book_borrower_time()
borrowed_book.The_book()

书的名字：谁动了我的奶酪
书的价值:20
借书人的名字：小强强
请输入：你的借书时间：2021.05.21.13.14
请输入：你的借书时间：2021.05.21.1314
请输入：你的还书时间：2022.05.21.13.14
借书时间：202.05.21.13.14

修改属性的值

可以以三种不同的方式修改属性的值：直接通过实例进行修改；通过方法进行设置；通过方法进行递增（增加特定的值）。下面依次介绍这些方法。

class Kettle():"""一次模拟水壶"""def __init__(self,form,material_quality):"""初始化属性形状，材质"""self.form=formself.material_quality=material_qualityself.big=0"""定义水浒属性大小为0"""print("水壶的形状："+form)print("水壶的材质："+material_quality)print("水壶的大小："+str(self.big))
my_kettle=Kettle('circular','glass')

水壶的形状：circular
水壶的材质：glass
水壶的大小：0

现在我们定义水壶的深度属性为零

直接修改属性的值

要修改属性的值，最简单的方式是通过实例直接访问它。

class Kettle():"""一次模拟水壶"""def __init__(self,form,material_quality):"""初始化属性形状，材质"""self.form=formself.material_quality=material_qualityself.big=0"""定义水浒属性大小为0"""print("水壶的形状："+form)print("水壶的材质："+material_quality)def bigs(self):print("水壶的大小："+str(self.big))
my_kettle=Kettle('circular','glass')
my_kettle.big=5
my_kettle.bigs()

水壶的形状：circular
水壶的材质：glass
水壶的大小：5

通过方法修改属性的值
如果有替你更新属性的方法，将大有裨益。这样，你就无需直接访问属性，而可将值传递给一个方法，由它在内部进行更新。

   def __init__(self,form,material_quality):"""初始化属性形状，材质"""self.form=formself.material_quality=material_qualityself.big=0"""定义水浒属性大小为0"""print("水壶的形状："+form)print("水壶的材质："+material_quality)def bigs(self):if 20>=self.big>=10:print("水壶的大小："+str(self.big))else:print("水壶的大小：" + str(self.big))print("这个水壶太大或太小了，不符合标准")
my_kettle=Kettle('circular','glass')
my_kettle.big=5
my_kettle.bigs()

水壶的形状：circular
水壶的材质：glass
水壶的大小：5
这个水壶太大或太小了，不符合标准

通过方法对属性的值进行递增
有时候需要将属性值递增特定的量，而不是将其设置为全新的值。

class Kettle():"""一次模拟水壶"""def __init__(self,form,material_quality):"""初始化属性形状，材质"""self.form=formself.material_quality=material_qualityself.big=0"""定义水浒属性大小为0"""print("水壶的形状："+form)print("水壶的材质："+material_quality)def change(self):self.big = self.big + 5def bigs(self):if 20>=self.big>=10:print("水壶的大小："+str(self.big))else:print("水壶的大小：" + str(self.big))print("这个水壶太大或太小了，不符合标准")
my_kettle=Kettle('circular','glass')
my_kettle.big=5
my_kettle.change()
my_kettle.bigs()

水壶的形状：circular
水壶的材质：glass
水壶的大小：10

继承

编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的
类称为父类，而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

子类的方法init()

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__init__() 需要父类施以援手。
父类
我们定义一张海报

class Bill():"""一次模拟海报"""def __init__(self,area,design,price):"""海报的初始属性面积，图画，价格"""self.area=areaself.design=designself.price=pricedef areas(self,prices):"""固定不同面积的海报价格不同"""if self.area>=10:prices+=self.priceelse:prices+=self.pricemill="面积："+str(self.area)+"\n图案"+self.design.title()print(mill)print("价格："+str(prices)+"元")

子类
我们定义海报的种类

class Design(Bill):def __init__(self,area,design,price):super().__init__(area,design,price)def designs(self):print("海报的图案:")design=("球星","人物","花草","山水")print(design)
mu=Design(19,"yuan long ping",5)
mu.areas(5)
mu.designs()

面积：19
图案Yuan Long Ping
价格：10元
海报的图案:
(‘球星’, ‘人物’, ‘花草’, ‘山水’)

首先在父类Bill的代码时。我们创建子类Design时，父类必须包含在当前文件中，且位于子类前面。定义子类时，必须在括号内指定父类的名称。
子类第二行代码：方法__init__接受创建Bill实例所需要的信息
子类第三行代码：super()是一个特殊的函数，帮助phyton将父类和子类关联起来。这行代码让phyton调用Design的父类的方法__init__（）
让Design的实例包含父类所有属性
父类也称为超类（superclass），名称super因此而得名。
为测试继承是否能够正确地发挥作用，我们尝试创建一张海报，但提供的信息与创建普通海报相同。在子类代码8处，我们创建Design 类的一个实例，并将其存储在变
量mu 中。这行代码调用Design类中定义的方法__init__() ，后者让Python调用父类Hill 中定义的方法__init__() 。我们提供了实参19,“yuan long ping”,5
除方法__init__() 外，海报没有其他特有的属性和方法。

给子类定义属性和方法

让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法

class Bill():"""一次模拟海报"""def __init__(self,area,design,price):"""海报的初始属性面积，图画，价格"""self.area=areaself.design=designself.price=pricedef areas(self,prices):"""固定不同面积的海报价格不同"""if self.area>=10:prices+=self.priceelse:prices+=self.pricemill="面积："+str(self.area)+"\n图案"+self.design.title()print(mill)print("价格："+str(prices)+"元")
class Price(Bill):def __init__(self,area,design,price):super().__init__(area,design,price)self.gift="li bai"print("买海报送张："+self.gift+"一张。")
mu=Price(19,"yuan long ping",5)
mu.areas(5)

买海报送张：li bai一张。
面积：19
图案Yuan Long Ping
价格：10元

在子类价格类中我定义新的属性买海报 libai 一张。

重写父类的方法

对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这
个父类方法，而只关注你在子类中定义的相应方法。

    def __init__(self,area,design,price):"""海报的初始属性面积，图画，价格"""self.area=areaself.design=designself.price=pricedef areas(self,prices):"""固定不同面积的海报价格不同"""if self.area>=10:prices+=self.priceelse:prices+=self.pricemill="面积："+str(self.area)+"\n图案"+self.design.title()print(mill)print("价格："+str(prices)+"元")def like(self):print("你喜欢不喜欢，这张海报")
class Price(Bill):def __init__(self,area,design,price):super().__init__(area,design,price)self.gift="li bai"print("买海报送张："+self.gift+"一张。")def like(self):print("这张海报的价格怎么样。")
mu=Price(19,"yuan long ping",5)
mu.areas(5)
mu.like()

买海报送张：li bai一张。
面积：19
图案Yuan Long Ping
价格：10元
这张海报的价格怎么样。

在父类中我们定义like这个方法。但是我们又在子类进行修改。

将实例用作属性

使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。
你可以将大型类拆分成多个协同工作的小类。

class Book():def __init__(self,name,author):self.name=nameself.author=authorbook="书的名字："+name+"\n书的作者："+authorprint(book)def book_names(self):book_name = ["phyton", "c", "java"]print(book_name)
class Name():def __init__(self):name=['xiya','guli','keli']for nam in name:print("书的作者有"+nam)
class Price(Book):def __init__(self,name,author):super().__init__(name,author)self.name=Namedef prices(self,price=5):book=input("请输入你想要的书：")if book=="phyton":price+=15elif book=="c":price+=34else:price+=30print("这本书的价格："+str(price)+"元。")def book_names(self):print("")
my_book=Price("c","xiya")
my_book.prices()
my_book.book_names()

书的名字：c
书的作者：xiya
请输入你想要的书：c
这本书的价格：39元。

在子类Price中的在第三行代码self.name=Name就是将类的一部分作为一个独立的类提取出来。来表示

在子类Price中的在第13行代码，我们也对父类方法
def book_names(self):
print("")
进行修改

导入类

——-导入类与导入函数是一样的
随着你不断地给类添加功能，文件可能变得很长，即便你妥善地使用了继承亦如此。为遵循Python的总体理念，应让文件尽可能整洁。为在这方面提供帮助，Python允许你将类存储在模块中，然后在主程序中导入所需的模块。
中，然后在主程序中导入所需的模块。

导入单个类

下面来创建一个只包含Car 类的模块。这让我们面临一个微妙的命名问题：如果已经有一个名为car.py的文件，但这个模块也应命名为car.py，因为它包含表示汽车的代码。我们将这样解决这个命名问题：将Car 类存储在一个名为car.py的模块中，该模块将覆盖前面使用的文件car.py。从现在开始，使用该模块的程序都必须使用更具体的文件名，如my_car.py。下面是模块car.py，其中只包含Car 类的代码：

class Car():"""一次模拟汽车的简单尝试"""def __init__(self, make, model, year):"""初始化描述汽车的属性"""self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):"""返回整洁的描述性名称"""long_name = str(self.year) + ' ' + self.make + ' ' + self.modelreturn long_name.title()def read_odometer(self):"""打印一条消息，指出汽车的里程"""print("This car has " + str(self.odometer_reading) + " miles on it.")def update_odometer(self, mileage):""" 将里程表读数设置为指定的值拒绝将里程表往回拨"""if mileage >= self.odometer_reading:self.odometer_reading = mileageelse: print("You can't roll back an odometer!")def increment_odometer(self, miles):"""将里程表读数增加指定的量"""self.odometer_reading += miles

在第一行代码处，我们包含了一个模块级文档字符串，对该模块的内容做了简要的描述。你应为自己创建的每个模块都编写文档字符串。
下面来创建另一个文件——my_car.py，在其中导入Car 类并创建其实例：my_car.py

from car import Car
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

第一行的代码处的import 语句让Python打开模块car ，并导入其中的Car 类。这样我们就可以使用Car 类了，就像它是在这个文件中定义的一样。输出与我们在前面看到的一样：

2016 Audi A4
This car has 23 miles on it.

导入类是一种有效的编程方式。如果在这个程序中包含了整个Car 类，它该有多长呀！通过将这个类移到一个模块中，并导入该模块，你依然可以使用其所有功能，但主程序文件变得整洁而易于阅读了。这还能让你将大部分逻辑存储在独立的文件中；确定类像你希望的那样工作后，你就可以不管这些文件，而专注于主程序的高级逻辑了。

在一个模块中存储多个类

虽然同一个模块中的类之间应存在某种相关性，但可根据需要在一个模块中存储任意数量的类。类Battery 和ElectricCar 都可帮助模拟汽车，因此下面将它们都加入模块
car.py中：

class Car():"""一次模拟汽车的简单尝试"""def __init__(self, make, model, year):"""初始化描述汽车的属性"""self.make = makeself.model = modelself.year = yearself.odometer_reading = 0def get_descriptive_name(self):"""返回整洁的描述性名称"""long_name = str(self.year) + ' ' + self.make + ' ' + self.modelreturn long_name.title()def read_odometer(self):"""打印一条消息，指出汽车的里程"""print("This car has " + str(self.odometer_reading) + " miles on it.")def update_odometer(self, mileage):""" 将里程表读数设置为指定的值拒绝将里程表往回拨"""if mileage >= self.odometer_reading:self.odometer_reading = mileageelse:print("You can't roll back an odometer!")def increment_odometer(self, miles):"""将里程表读数增加指定的量"""self.odometer_reading += miles
class Battery():"""一次模拟电动汽车电瓶的简单尝试"""def __init__(self, battery_size=60):"""初始化电瓶的属性"""self.battery_size = battery_sizedef describe_battery(self):"""打印一条描述电瓶容量的消息"""print("This car has a " + str(self.battery_size) + "-kWh battery.")def get_range(self):"""打印一条描述电瓶续航里程的消息"""if self.battery_size == 70:range = 240elif self.battery_size == 85:range = 270message = "This car can go approximately " + str(range)message += " miles on a full charge."print(message)
class ElectricCar(Car):"""模拟电动汽车的独特之处"""def __init__(self, make, model, year):""" 初始化父类的属性，再初始化电动汽车特有的属性"""super().__init__(make, model, year)self.battery = Battery()

现在，可以新建一个名为my_electric_car.py的文件，导入ElectricCar 类，并创建一辆电动汽车了：

from car import ElectricCar
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

2016 Tesla Model S
This car has a 70-kWh battery.
This car can go approximately 240 miles on a full charge.

从一个模块中导入多个类

可根据需要在程序文件中导入任意数量的类。如果我们要在同一个程序中创建普通汽车和电动汽车，就需要将Car 和ElectricCar 类都导入
my_cars.py

from car import Car, ElectricCar❷ my_beetle = Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())

在第三行代码处从一个模块中导入多个类时，用逗号分隔了各个类。导入必要的类后，就可根据需要创建每个类的任意数量的实例。
在这个示例中，我们在第二行代码处创建了一辆大众甲壳虫普通汽车，并在第一行代码处创建了一辆特斯拉Roadster电动汽车：

2016 Volkswagen Beetle
2016 Tesla Roadster

导入整个模块

你还可以导入整个模块，再使用句点表示法访问需要的类。这种导入方法很简单，代码也易于阅读。由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称
发生冲突。
下面的代码导入整个car 模块，并创建一辆普通汽车和一辆电动汽车：

import car
my_beetle = car.Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())
my_tesla = car.ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name

在第一行代码处，我们导入了整个car 模块。接下来，我们使用语法 module_name.class_name 访问需要的类。像前面一样，我们在第二行代码处创建了一辆大众甲壳虫汽车，并在第二行代码处创建了一辆特斯拉Roadster汽车。

导入模块中的所有类

要导入模块中的每个类，可使用下面的语法：
from module_name import *
这个只是了解，就可以了。

在一个模块中导入另一个模块

有时候，需要将类分散到多个模块中，以免模块太大，或在同一个模块中存储不相关的类。将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下，可在前一个模块中导入必要的类。
例如，下面将Car 类存储在一个模块中，并将ElectricCar 和Battery 类存储在另一个模块中。我们将第二个模块命名为electric_car.py （这将覆盖前面创建的文件
electric_car.py），并将Battery 和ElectricCar 类复制到这个模块中：
electric_car.py
可用于表示电动汽车的类"""

❶ from car import Car
class Battery():
–snip–
class ElectricCar(Car):
–snip–

ElectricCar 类需要访问其父类Car ，因此在❶处，我们直接将Car 类导入该模块中。如果我们忘记了这行代码，Python将在我们试图创建ElectricCar 实例时引发错误。
我们还需要更新模块car ，使其包含Car 类：
car.py

“”“一个可用于表示汽车的类”""
class Car():
–snip–

现在可以分别从每个模块中导入类，以根据需要创建任何类型的汽车了：
my_cars.py

❶ from car import Car
from electric_car import ElectricCarmy_beetle = Car(‘volkswagen’, ‘beetle’, 2016)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar(‘tesla’, ‘roadster’, 2016)
print(my_tesla.get_descriptive_name())

在❶处，我们从模块car 中导入了Car 类，并从模块electric_car 中导入ElectricCar 类。接下来，我们创建了一辆普通汽车和一辆电动汽车。这两种汽车都得以正确地
创建：
2016 Volkswagen Beetle
2016 Tesla Roadster

自定义工作流程

正如你看到的，在组织大型项目的代码方面，Python提供了很多选项。熟悉所有这些选项很重要，这样你才能确定哪种项目组织方式是最佳的，并能理解别人开发的项目。
一开始应让代码结构尽可能简单。先尽可能在一个文件中完成所有的工作，确定一切都能正确运行后，再将类移到独立的模块中。如果你喜欢模块和文件的交互方式，可在项目
开始时就尝试将类存储到模块中。先找出让你能够编写出可行代码的方式，再尝试让代码更为组织有序。

Python标准库

Python标准库是一组模块，安装的Python都包含它。你现在对类的工作原理已有大致的了解，可以开始使用其他程序员编写好的模块了。可使用标准库中的任何函数和类，为此
只需在程序开头包含一条简单的import 语句。下面来看模块collections 中的一个类——OrderedDict 。
字典让你能够将信息关联起来，但它们不记录你添加键—值对的顺序。要创建字典并记录其中的键—值对的添加顺序，可使用模块collections 中的OrderedDict 类。OrderedDict 实例的行为几乎与字典相同，区别只在于记录了键—值对的添加顺序。

❶ from collections import OrderedDict
❷ favorite_languages = OrderedDict()
❸ favorite_languages[‘jen’] = ‘python’
favorite_languages[‘sarah’] = ‘c’
favorite_languages[‘edward’] = ‘ruby’
favorite_languages[‘phil’] = ‘python’
❹ for name, language in favorite_languages.items():
print(name.title() + "'s favorite language is " +
language.title() + “.”)

我们首先从模块collections 中导入了OrderedDict 类（见❶）。在❷处，我们创建了OrderedDict 类的一个实例，并将其存储到favorite_languages 中。请注
意，这里没有使用花括号，而是调用OrderedDict() 来创建一个空的有序字典，并将其存储在favorite_languages 中。接下来，我们以每次一对的方式添加名字—语言
对（见❸）。在❹处，我们遍历favorite_languages ，但知道将以添加的顺序获取调查结果：

Jen’s favorite language is Python.
Sarah’s favorite language is C.
Edward’s favorite language is Ruby.
Phil’s favorite language is Python.

这是一个很不错的类，它兼具列表和字典的主要优点（在将信息关联起来的同时保留原来的顺序）。等你开始对关心的现实情形建模时，可能会发现有序字典正好能够满足需
求。随着你对标准库的了解越来越深入，将熟悉大量可帮助你处理常见情形的模块。

类编码风格

你必须熟悉有些与类相关的编码风格问题，在你编写的程序较复杂时尤其如此。
类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文
档字符串，对其中的类可用于做什么进行描述。
可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。
需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import 语句，再添加一个空行，然后编写导入你自己编写的模块的import 语句。在包含多
条import 语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方。

phyton的函数与类的学习相关推荐

【C++】C++类的学习（五）——纯虚函数与抽象类
[fishing-pan:https://blog.csdn.net/u013921430转载请注明出处] 前言在前面的博客中讲到了虚函数,今天讲述一种特别的虚函数--纯虚函数,以及与之相关的抽象类 ...
【C++】C++类的学习（三）——运算符重载与友元函数
[fishing-pan:https://blog.csdn.net/u013921430转载请注明出处] 前言前面的两篇博文中介绍了类的一些基本特性,今天讲一讲运算符重载和友元. 运算符重载运算 ...
C++ 学习 ::【基础篇：13】：C++ 类的基本成员函数：类类型成员的初始化与构造函数问题
本系列 C++ 相关文章仅为笔者学习笔记记录,用自己的理解记录学习!C++ 学习系列将分为三个阶段:基础篇.STL 篇.高阶数据结构与算法篇,相关重点内容如下: 基础篇:类与对象(涉及C++的三大特 ...
C++ 学习 ::【基础篇：17】：C++ 类与对象：运算符重载介绍、运算符重载函数（类内与类外区别）写法及简单设计实现
本系列 C++ 相关文章仅为笔者学习笔记记录,用自己的理解记录学习!C++ 学习系列将分为三个阶段:基础篇.STL 篇.高阶数据结构与算法篇,相关重点内容如下: 基础篇:类与对象(涉及C++的三大特 ...
js学习（三）--同样灵活的函数、类
文章目录函数声明方式形参学习返回值函数执行符开发中常用样式类学习类的声明类的使用类的"继承" 自定义对象函数函数的作用:功能代码块的封装,减少重复代码.代码 ...
基类指针调用派生类函数_C++ 多态性：虚函数--基类与派生类类型转换（第7章 05）例子问题解析（学习笔记：第8章 05）...
虚函数[1] 问题:还记得第7章的例子吗[2]? 例7-3 类型转换规则举例 #include <iostream> using namespace std; class Base1 { ...
python 如何查看模块所有方法-Python查看模块（变量、函数、类）方法
前面章节中,详细介绍了模块和包的创建和使用(严格来说,包本质上也是模块),有些读者可能有这样的疑问,即正确导入模块或者包之后,怎么知道该模块中具体包含哪些成员(变量.函数或者类)呢? 查看已导入模块( ...
python调用其他文件中的函数或者类
1 .在同一个文件夹下,调用函数或者类 A.py文件中 def test():print('this is test func')class A:def test():print('this is a ...
【Python面试】说说Python变量、函数、类的命名规则？
往期面试题: 谈谈对 Python 和其他语言的区别? 说说4种常用编码的区别? 说说Python面向对象三大特性? 说说Python中有几种数据类型? 废话不多说,开始今天的题目: 问:Python ...
【JavaScript】JS的变量、数组、计算器案例、函数、类、常用对象的方法
目录 01-js-js的声明和引入 <!DOCTYPE html> <html><head><meta charset="UTF-8"&g ...

phyton的函数与类的学习

phyton的函数的学习

定义函数

**实参和形参

** 传递任意数量的实参**

传递实参

位置实参的顺序很重要

关键字实参

结合使用位置实参和任意数量实参

使用任意数量的关键字实参

默认值

返回值

返回字典

结合使用函数和while 循环

传递列表

在函数中修改列表

禁止函数修改列表

将函数存储在模块中

导入整个模块

导入特定的函数

使用as 给函数指定别名

使用as 给模块指定别名

给模块指定别名的通用语法如下：

导入模块中的所有函数

编写函数的注意事项

类

创建和使用类

根据类创建实例

使用类和实例

给属性指定默认值

修改属性的值

继承

子类的方法__init__()

给子类定义属性和方法

重写父类的方法

将实例用作属性

导入类

导入单个类

在一个模块中存储多个类

从一个模块中导入多个类

导入整个模块

导入模块中的所有类

在一个模块中导入另一个模块

自定义工作流程

Python标准库

类编码风格

phyton的函数与类的学习相关推荐

最新文章

热门文章

`**实参和形参`

传递任意数量的实参

子类的方法init()