《python从入门到实践》
目录
1、字符串
①title方法（方法是python对数据执行的操作。一般方法后面都需要接一对括号，因为方法都需要额外信息，如果没有额外信息，则接空括号）是以首字母大写，其他字母小写的方式来显示字符串中的每一个单词。
name="ada ADA aDA Ada"
print(name)输出结果：
②upper方法，将字符串的每一个字母改成大写
③lower方法，将字符串的每一个字母改成小写
④使用加号（“+”）来连接字符串
⑤要在字符串中添加制表符，可使用字符组合\t ；要在字符串中添加换行符，可使用字符组合\n
name="python\n\thello\nworld"
print(name)输出结果：
⑥strip()方法用于删除字符串开头和结尾的空格，lstrip()方法用于删除字符串开头的空格，rstrip()方法用于删除字符串结尾的空格。
2、数字
①**表示乘方
②浮点数的运算结果，小数的位数可能是不确定的
③在python2中，整数之间的除法得到的结果只会是整数，结果会将小数部分直接舍去。比如，3/2，返回结果为1。为了避免这种情况（想要得到的结果是真实浮点数值），输入时务必确保有一个操作数为浮点数。
3、注释器
在python中使用#来注释文本
4、python之禅
import this
5、列表
列表是一组有顺序的元素的组合。bi['a','b','c']
①列表使用一组中括号表示（[ ]），用逗号来分隔其中的元素
②访问列表元素，使用列表名加索引，索引从0开始；访问列表最后一个元素，可以用索引（-1）
③添加元素：(1)append()方法：在表尾添加元素，如：bi.append('d')
(2)insert()方法：加上索引在列表任何位置添加元素，如：bi,insert(0,'A')，则0号元素就为A。
insert方法插入元素时需要写入索引位置信息，插入的新元素即在写入时的索引位置。
④删除元素：(1)pop()方法：在表尾删除元素，如：bi.pop()
(2)del方法：加上索引信息，删除在列表中任一位置的元素，如：del bi[0]
(3)实际上也可以使用pop()方法来删除列表中的任一位置的元素，只需要在pop方法的括号中加入元素索引信息即 可。如：bi.pop(0)
(4)remove方法：当不知道删除元素的索引时，只知道删除元素的内容，就可以用remove()，remove()方法每一次 只能删除列表中第一个为该元素的值，若想要全部删除该元素，需要使用循环语句。
注意：del方法没有返回值，而pop方法有返回值。如果你不确定该使用del 语句还是pop() 方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句；如果你要在删除元 素后还能继续使用它，就使用方法pop() 。
⑤组织列表（列表排序）：(1).sort()方法：对列表按Ascii码进行永久性的排列（升序(数字在前，字母在后；大写字母在前，小 写字母在后)）；若要逆序，则只需要向sort方法传递参数reverse=True，即sort(reverse = True)
(2)sorted()方法：对列表进行临时性升序排序，不改变原列表值。该方法的调用不是使用点方法来调 用，而是直接将列表名作为参数传递给sorted方法，如：sorted(bi)；若要逆序则使用 sorted(bi,reverse=True)
(3).reverse()方法：永久性直接对列表元素逆序排序
⑥获取列表长度：len()方法，如：len(bi)
6、操作列表
①循环列表：使用for循环遍历整个列表：可以使用临时变量存储列表中的每一个值。列如：
bis=['asfas','asfdas''er','dfg','wer',2]
for bi in bis:
print(str(bi)+' is bis')输出结果：
②在for循环中，可对每个元素进行任何操作，如：
magicians = ['alice', 'david', 'carolina']
for magician in magicians:
print(magician.title() + ", that was a great trick!")
print("I can't wait to see your next trick, " + magician.title() + ".\n")输出结果：
③使用range()函数产生一串数字，如
for num in range(1,9,2):
print num
输出结果：
range函数的前两个参数表示，所要输出数字的范围，此范围不包括最后一个参数值，如上面的例子，所要输出的数字范围即为1到8。函数的第三个参数表示步长，也就是输出数字串的间隔，上面的例子就表示以间隔为2，输出1到9之间的数字。
④使用range()函数创建数字列表：结合list()方法，可以创建一个数字列表，range函数作为list方法的参数，如：
bis = list(range(1,9,2))
print(bis)输出结果：
使用range函数几乎可以创建任意一个数字列表（思想：首先创建一个空列表，然后通过range方法创建数字，并不断的添加到列表中），如创建一个列表，其中包含前10个整数（即1~10）的平方：
squares = []
for num in range(1,11):
squares.append(num ** 2)
print(squares)输出结果：
⑤对数字列表进行简单的统计：
（1）求数字列表最大最小值：max()函数和min()函数，如min(bi)
（2）求数字列表的数字总和：sum()函数，如sum(bi)
⑥列表解析：将for 循环和创建新元素的代码合并成一行，并自动 附加新元素。要使用这种语法，首先指定一个描述性的列表名，然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值，接下来，编写一个for 循环，用于给表达式提供值，再加上右方括号。如，上面输出1到10平方的列表可写成列表解析的形式：
squares = [num ** 2 for num in range(1,11)]⑦列表切片：截取列表中的一部分。基本语法：列表名[第一个索引:第二个索引]，其索引从0开始，截取结果不包括第二个索引 值，列表中的最后一个元素的索引为-1。如：
bis = ['0sf','1ert','2fg','3ret','4try']
print(bis[0:2])输出结果：
如果省略第一个索引参数，则自动从列表的第一个元素开始切片；如果省略第二个参数，则自动索引到列表的最后一个元素。
⑧遍历切片：与遍历range()函数一样，只要把range()函数改成列表切片即可，如：
bis=list(range(1,21))
for bi in bis[:2]:
print bi
输出结果：
⑨复制列表：即对一个列表进行从首到尾的列表切片：[:]，如：
bi1=list(range(1,15))
bi2=bi1[:]
bi1.append('this is 1')
bi2.append('this is 2')
print bi1
print bi2输出结果：
由上面的例子可以看出，通过列表切片的方式对列表进行赋值，列表实现复制，在对一个列表进行改变时，另一个列表并不会随之改动。
#错误做法：简单的将一个列表赋值给另一个新的列表，不使用列表切片的方式，如：
bi1=list(range(1,15))
bi2=bi1
bi1.append('this is 1')
bi2.append('this is 2')
print bi1
print bi2输出结果：
由此我们可以看出，只是将两个列表进行简单的赋值后，bi1和bi2实际上都指向同一个列表，不论我们对哪一个列表进行操作，另一个列表也会随之改动。
7、元组
元组使用一组小括号进行标识，看起来和列表一样，但是列表元素是可以随意改变的，元组元素则为一组不可变的元素。可以使用索引来访问元组元素，方法、书写格式与列表一样。遍历元组的方法也是一样的，同样可以使用for循环。注：元组元素不可以使用索引的方式进行重新赋值，但可以给同样名称的元组进行重定义。
8、if语句
①检查元素：(1)python中使用“==”，“!=”来判断两个元素是否相等时，严格按照大小写的规则，若要避免大小写，可以使用 lower()函数或者upper()函数来对字符进行相应的转换。
(2)检查多个条件，则可以用and进行条件连接，为了改善代码的可读性，可以用小括号将每个条件分隔开来。关 键字or 也能够让你检查多个条件，但只要至少有一个条件满足，就能通过整个测试。
(3)使用关键字“in”来检查特定的元素是否在列表中，使用“not in”来检查特定元素是否不在列表中。
(4)还可以使用布尔表达式来作为测试条件。
②if语句的结构：if-elif-else，一个代码块中可使用多个elif，作为递进条件判断；写在多个代码块中的平行条件判断可用多个if语 句。
③对列表操作for循环前先确定列表不为空：if 列表名:
9、字典
在Python中，字典 字典 是一系列键 键—值对 值对 。每个键 键 都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将 任何Python对象用作字典中的值。 在Python中，字典用放在花括号{} 中的一系列键—值对表示。键和值之间用冒号分隔，而键—值对之间用逗号分隔。如下所示，定义一个dic字典，并根据其键访问其值：
dic = {0:'as','two':'qw',3:"zx"}
print(dic[0])
print(dic['two'])输出结果：
①字典是一种动态结构，可随时在其中添加键—值对。要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的 值。如对上面的dic字典添加键值对：4-ui
dic[4]="ui"
print(dic) 输出结果：
②要修改字典中的值，可依次指定字典名、用方括号括起的键以及与该键相关联的新值。如对上方dic字典修改键值对4-ui为4-er
dic[4] = "er"
print(dic)输出结果：
③删除键值对：对于字典中不再需要的信息，可使用del 语句将相应的键—值对彻底删除。使用del 语句时，必须指定字典名和 要删除的键。 如将上方dic字典的0-as键值对删除。
del dic[0]
print(dic)输出结果：
④遍历字典
(1)遍历得到键和值：要编写用于遍历字典的for 循环，可声明两个变量，用于存储键—值对中的键和值。对于这两个变量，可使 用任何名称。for 语句的第二部分包含字典名和方法items()，它返回一个键—值对列表。接下来，for 循环依次将每个键—值 对存储到指定的两个变量中。如遍历上面的dic字典：
for key,value in dic.items():
print("key:" + str(key))
print("value:" + value)输出结果：
注意这里的items()方法，该方法将字典里的键值对转换成一个键值对列表，如对上面的dic字典调用items()方法：
print(dic.items())输出结果：
(2)遍历得到所有的键：对字典调用keys()方法，然后使用for循环遍历，如对上面的dic字典进行键遍历：
for key in dic.keys():
print(key)输出结果：
(3)按顺序遍历字典中的所有键：调用keys()方法取出所有的键后，在调用sort()方法，对所有的键进行排序，如：
favorite_languages = {'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'python', }
for name in sorted(favorite_languages.keys()):
print(name.title() + ", thank you for taking the poll.")输出结果：
(4)遍历得到所有的值：对字典调用values()方法，然后使用for循环遍历，如对上面的dic字典进行值遍历：
for value in dic.values():
print(value)输出结果：
(5)通过上面的方法提取字典中的值，并没有考虑值的重复性，如果字典中的很多重复的值，使用values()方法后遍历会得到大量 重复的值，为剔除重复项，可使用set()集合，集合类似于列表，但每个元素都是独一无二的。如：
favorite_languages = {'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'python', }
for value in set(favorite_languages.values()):
print(value)输出结果：
⑤嵌套：将字典存放在列表中、将列表存放在字典中、将字典存放在字典中......
(1)将字典存放在列表中：如：
lists = []
for num in range(1,3):
dics={"name":"cheng","age":18,"sex":"f"}
lists.append(dics)
print(lists)输出结果：
(2)将列表存放在字典中：如：
dics = {"name":"cheng",
"likes":["food","running","movie"],
"age":18
}
for like in dics["likes"]:
print("cheng likes: " + like)输出结果：
(3)将字典存放在字典中：如：
users = {
'aeinstein': {
'first': 'albert',
'last': 'einstein',
'location': 'princeton',
},
'mcurie': {
'first': 'marie',
'last': 'curie',
'location': 'paris',
},
}
for use,info in users.items():
print("use is:" + use)
print("fullname is :" + info["first"] +" " + info["last"])
print("location is:" + info["location"])输出结果：
10、用户输入
①input()函数：暂停程序，等待用户输入一些文本。获取用户输入后，python将其存储在一个变量中，以方便使用。
在python2.7中，对input()的输入严格按照python的规则来，也就是说，若输入为字符串，则需要给输入加引号。如：
num = input("请输入一个数： ")
if num % 10 == 0:
print(str(num) + "是10的倍数")
else:
print(str(num) + "不是10的倍数")输出结果：
②raw_input()函数：该函数作用与input()函数一样，都是完成用户的输入，但raw_input()函数的输入不用严格按照python规 则，也就是说若输入为字符串，则直接输入就行，不用添加引号，但raw_input()函数将所有的输入都当做是字符，也就是 说，如果输入为数字，并且在之后的操作中要将此输入作为数字使用，则还需要使用int()函数做强制字符转换。如：
num = raw_input("请输入一个数： ")
if int(num) % 10 == 0:
print(num + "是10的倍数")
else:
print(num + "不是10的倍数")
输出结果：
11、while循环
for 循环用于针对集合中的每个元素都一个代码块，而while 循环不断地运行，直到指定的条件不满足为止。如：
prompt = "\nTell me something, and I will repeat it back to you:\nEnter 'quit' to end the program."
message = ""
while message != 'quit':
message = raw_input(prompt)
if message != 'quit':
print(message)输出结果：
①使用标志作为循环判断条件：只要标志为True则继续执行代码，否则停止循环。如：
prompt = "\nTell me something, and I will repeat it back to you:\nEnter 'quit' to end the program."
message = True
while message :
message = raw_input(prompt)
if message == 'quit':
message = False
else:
print(message)输出结果：
②使用break退出循环：要立即退出while 循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用break 语 句。break 语句用于控制程序流程，可使用它来控制哪些代码行将执行， 哪些代码行不执行，从而让程序按你的要求执行你 要执行的代码。
#coding=utf-8
prompt = "\nTell me something, and I will repeat it back to you:\nEnter 'quit' to end the program."
message = True
while message :
message = raw_input(prompt)
if message == 'quit':
break
else:
print(message)③使用continue退出当前一次循环，但不退出整个循环：要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue 语句，它不像break 语句那样不再执行余下的代码并退出整个循环。如：
num = 0
while num < 5:
num += 1
if num % 2 == 0:
continue
print(num)输出结果：
(2)删除包含特定值的所有列表元素（使用remove()方法可以删除列表中的一个特定元素），如：
yanzheng = ["lu","cheng","wei","liang","lu"]
while "lu" in yanzheng:
yanzheng.remove("lu")
print(yanzheng)输出结果：
(3)使用用户输入来填充字典
responses ={}
answer = True
while answer:
name = raw_input("请输入你的名字：")
response = raw_input("请输入你的答案:")
responses[name] = response
again = raw_input("请问是否愿意继续回答:(yes/no)")
if again == "no":
answer = False
for name,response in responses.items():
print("调查者名字是：" + name)
print("调查者回答是：" + response)
输出结果：
12、函数
①定义函数：使用关键字def 来告诉Python你要定义一个函数。这是函数定义 ，向Python指出了函数名，还可能在括号内指出函数为完成其任务需要什么样的信息。要使用这个函数，可调用它。函数调用 让Python执行函数的代码。要调用函数，可依次指定函数名以及用括号括起的必要信息。这里，在函数定义中用到的参数称为“形参”，在函数调用中用到的参数称为“实参”。
def hello(name):
print("hello "+name)
name = raw_input("请输入你的名字：")
while name:
hello(name)
name = raw_input("请输入你的名字：")输出结果：
②传递实参：
(1)位置实参：调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参 。如：
def eating(time,food):
print("现在是" + time +"点")
print("现在要吃：" + food)
eating("9","mike")输出结果：
(2)关键字实参：关键字实参 是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆，关键字实参让 你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。如：
def eating(time,food):
print("现在是" + time +"点")
print("现在要吃：" + food)
eating(food="mike",time = "9")输出结果：
(3)默认值：编写函数时，可给每个形参指定默认值。在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用法。 如：
def eating(time,food = "mike"):
print("现在是" + time +"点")
print("现在要吃：" + food)
eating(time = "9")
eating("12","apple")输出结果：
③返回值：
(1)函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值 。在函数中，可使用return 语句将值返回到调用函数的代码行。 返回值让你能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。 如：
def get_fullname(first,last):
full_name = first + " " + last
return full_name
mom = get_fullname("wang","xia")
print(mom)输出结果：
(2)实参可选：一个函数中可能包括多个参数，但是我们有时候并不一定在使用函数时都有这些参数，所以，可以使用默认值让参数变得可选，这样使用函数的人就只需在必要时才提供额外的信息。注意：在给形参赋予默认值时，一定要将赋予默认值的形参放在参数的最后，不然会出错。 如：
def get_formatted_name(first_name,middle_name="",last_name=""):
if middle_name:
full_name = first_name + ' ' + middle_name + ' ' + last_name
else:
full_name = first_name + ' ' + last_name
return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
musician = get_formatted_name('john', 'lee','hooker')
print(musician)输出结果：
④返回字典：函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。如：
def full_name(first,last):
full_info={}
full_info["first_name"] = first
full_info["last_name"] = last
full_info["full_name"] = first + " " + last
return full_info
ch=full_name("cheng","lu")
print(ch)输出结果：
⑤结合使用while和函数，如：
def full_name(first,last):
full_info={}
full_info["first_name"] = first
full_info["last_name"] = last
full_info["full_name"] = first + " " + last
return full_info
first = raw_input("请输入你的名：")
last = raw_input("请输入你的姓：")
while first != "q" and last != "q":
ch = full_name(first,last)
print(ch)
first = raw_input("请输入你的名：")
last = raw_input("请输入你的姓：")输出结果：
⑥传递列表：向函数传递列表很有用，这种列表包含的可能是名字、数字或更复杂的对象（如字典）。将列表传递给函数后，函数就能直接访问其内容。当向一个函数传递一个列表时，可以多次执行该函数，其中的实参就为列表中的各个元素。如：
def full_name(name):
full_info={}
for first,last in name:
full_info["first_name"] = first
full_info["last_name"] = last
full_info["full_name"] = first + " " + last
print(full_info)
name = [("ceh","sdf"),("sd","er"),("we","io")]
full_name(name)输出结果：
⑦在函数中修改列表：将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。如：
ddef print_models(cons,kongs):
while cons:
con = cons.pop()
print("请打印：" + con)
kongs.append(con)
def ex_print(kongs):
for kong in kongs:
print("已经打印：" +kong)
cons = ["sd","sa","we"]
kongs = []
print_models(cons,kongs)
ex_print(reversed(kongs))
print("cons ="),
print(cons)输出结果：
⑧禁止函数修改列表：有时候，需要禁止函数修改列表。为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。将列表副本传递给函数，可以通过列表切片实现。切片表示法[:] 创建列表的副本。如：
def print_models(cons,kongs):
while cons:
con = cons.pop()
print("请打印：" + con)
kongs.append(con)
def ex_print(kongs):
for kong in kongs:
print("已经打印：" +kong)
cons = ["sd","sa","we"]
kongs = []
print_models(cons[:],kongs)
ex_print(reversed(kongs))
print("cons ="),
print(cons)输出结果：
⑨传递任意数量的实参：通过在形参名前加星号(*)的方式创建一个空元组，在一个函数中，元组形参只能有一个，且元组形参必须放在最后。在函数定义时，需要通过for循环来取元组里的所有值。如：
def full_name(first,*lasts):
for last in lasts:
full = first + "" + last
print("我姓：" + first)
print("我名：" + last)
print("我叫：" + full)
full_name("易","烊千玺","千岁","水")输出结果：
如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。 注，如上例中，形参名*lasts中的星号让python创建了一个名为lasts的空元组，并将收到所有的值都封装到这个元组中。
⑩使用任意数量的关键字实参，有时候，我们需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。这种情况下，课将函数编写成能够接受任意数量的键-值对——调用语句提供了多少就接受多少，在定义形参的时候，在形参前面加上两个星号，该形参就可以接收任意数量的实参。同样在定义函数时，要使用for循环来遍历键值对形参，特别的，在遍历这个形参时，要使用items()函数，将键值对转化成元组列表。如：
def info(pets,color,**cons):
full_info = {}
full_info["pet"] = pets
full_info["color"] = color
for key,value in cons.items():
full_info[key] = value
return full_info
dog = info("dog","white",location = "china",user = "qianxi",eat = "meet")
print(dog)输出结果：
⑾将函数存储在模块中：函数的优点之一就是，使用它们可以将代码块与主程序分离。通过给定的函数名，可以让主程序容易理解得多。还可以进一步，将函数存储在被称为模块的独立文件中，再将模块导入主程序中。使用import语句允许子啊当前允许的程序文件中使用模块中的代码。通过将模块函数存储在独立的文件中，可隐藏程序代码中的细节，将重点放在程序的高层逻辑上。下面介绍导入模块的方法：
(1)导入整个模块：要让函数是可导入的，首先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。如：
创建一个make模块：
def make_car(producter,xinghao,**qitas):
full_info = {}
full_info["producter"] = producter
full_info["xinghao"] = xinghao
for key,value in qitas.items():
full_info[key] = value
return full_info接下来，在make.py所在的目录中创建另一个名为car.py的文件，在这个文件中导入上面创建的make模块：
import make
car = make.make_car('subaru', 'outback', color='blue', tow_package=True)
print(car)代码行import make 让Python打开文件make.py，并将其中的所有函数都复制到这个程序中。你看不到复制的代码，因为这个程序运行时，Python在幕后复制这些代码。这就是一种导入方法：只需编写一条import 语句并在其中指定模块名，就可在程序中使用该模块中的所有函数。
(2)导入特定的函数，我们还可以导入模块中的特定函数，导入语法：from 模块名 import 函数名。通过用逗号分隔函数名，还可以根据需要从模块中导入任意数量的函数：from 模块名 import 函数名1，函数名2，函数名3。如：
from make import make_car
car = make_car('subaru', 'outback', color='blue', tow_package=True)
print(car)(3)使用as给函数指定别名：如果要导入的函数名称与程序中现有的函数名称冲突，或者函数名太长，可以指定简短而独一无二的别名——函数的另一个名称。要给导入的函数起别名，需要在导入函数时就这样做，同样，可以给模块起别名。如：
from make import make_car as mc
car = mc('subaru', 'outback', color='blue', tow_package=True)
print(car)(4)导入模块中所有的函数：from 模块名 import *
13、类
在面向对象的编程中，编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。编写类时，定义一个大类对象都有的通用行为。基于类创建对象时，每个对象都自动具备这种通用行为，然后可以根据需要赋予每个对象独特的个性。根据类来创建对象被称为实例化。
①创建一个类：根据约定，在Python中，首字母大写的名称指的是类，在python2.7中创建类时，需要在括号内加上“object”（class Dogs(object)）。如：
class Dogs(object):
def __init__(self,name,age):
self.name = name
self.age = age
def sit(self):
print(self.name.title() + "is now sitting.")
def roll_over(self):
print(self.name.title() + "rolled over!")
(1)__init__()方法：
类中的函数统称为方法，__init__()方法是python中一个特殊的方法。在一个类中若包含__init__()方法，则每一次调用这个类创建新的实例时，python都会自动运行它。在这个方法中，self形参是必不可少的，而且必须放在所有形参的最前面。使用类来创建实例时，将自动传入实参self，每个与类相关的方法都自动调用实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法，每一次创建实例时调用方法，都不用给形参self赋值，它会自动赋值。以self为前缀的变量可供类中的所有方法使用，我们还可以通过类的实例来访问这些变量。这样可通过实例访问的变量称为属性。在上例中，Dog 类还定义了另外两个方法：sit() 和roll_over() ，由于这些方法不需要额外的信息，如名字或年龄，因此它们只有一个形参self 。
②根据类创建实例，如：
my_dog = Dogs('willie', 6)
my_dog.sit()
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")
在这里创建了一个名为my_dog的实例，Python使用实参'willie' 和6 调用Dog 类 中的方法__init__()创建一个表示特定小狗的示例，并使用我们提供的值来设置属性name 和age。方法__init__() 并未显式地包含return 语句， 但Python自动返回一个表示这条小狗的实例。
(1)访问实例的属性和调用实例的方法都使用句点表示法。如：my_dog.name，my_dog.sit
(2)可以根据需求创建任意数量的实例
③④⑤⑥⑦⑧⑨⑩⑾⑿⒀⒁⒂⒃