Python笔记

本文摘自<<Python编程从入门到实践>>，为个人总结文档

第一部分 基础知识

第一章 起步

无

第二章 变量和简单数据类型

2.1 变量

-变量命名规则：

• 以字母、数字和下划线命名，不能以数字开头（不允许使用$符）
• python建议变量以小写字母加下划线命名（非驼峰命名方式），变量命名规则应简短又具有描述性

2.2 数据类型

-字符串

• python中以引号（包括单引号或双引号）包含的一系列字符称之为字符串，如：

      "Hello world"

      'Hello world'

      这种灵活性可以在字符串中包含双引号或单引号，如：

      'Tom told lily,"Python is my favorite language"'

      "One of Python's strength is its diverse and supportive community"    #python的强大原因之一是它的多样性及支持社区

• 字符串方法：

      修改字符串大小写：

　  title()    #单词首字母大写，其它部分小写

      upper()  lower()

      字符串拼接：+

      使用制表符或换行符来添加空白：\t \n

      删除空白：lstrip()  rstrip()  strip()

#2-3
name1 = "Gric"
print("Hello "+name1+",would you like to learn some Python today?")
#2-4
name2 = "Jimmy"
print("Upper name:"+name2.upper())
print("Lower name:"+name2.lower())
print("First Character Upper name:"+name2.title())
#2-5
name3="Alber Einstein"
print(name3+' once said,"A person who never made a mistake never tried anything new."')
#2-6
famous_person=name3
message=famous_person+' once said,"A person who never made a mistake never tried anything new."'
print(message)
#2-7
name4=" Elic "
print("LStrip name:"+name4.lstrip()+"\tRStrip name:"+name4.rstrip()+"\nStrip name:"+name4.strip())

-数字

• 整数

    在python中，可对整数执行加（+）、减（-）、乘（*）、除（/）运算，Python还支持运算次序

    注意：在python2中，整数相除结果为整数，小数位被截断，若要保留小数位，至少将除数或被除数之一设置为浮点数

    python以**代表幂运算，如2**3  #结果为8

• 浮点数
• 使用函数str()避免类型错误

    在python中，字符串后面的数字不能默认为字符串，使用函数str()将其转换为字符串

    注：可通过int()、long()、float()等函数将字符串转换为数字

-注释  #

-python之禅

    关键字：import this

第三章 列表简介

3.1 列表是什么

• 列表由一系列按特定顺序排列的元素组成
• 列表名建议由复数组成（如letters）
• 列表由方括号（[]）组成，并用逗号隔开其中的元素，如： 

          bicycles=['trek','cannondale','redline','specialized']

3.2 添加、删除、修改列表

-访问列表元素 

#index=0,1,2...

#index可以为负数（从-1开始），用于访问倒数第n个元素，如-2返回倒数第二个列表元素，-3返回倒数第三个列表元素

list_name[index]

#3-2
names=['huayongli','huangxiaoyan','hetao','fanhongtao','hujinlin','shixiang']
for name in names:
 print("Hello "+name+",nice to meet you")
#3-3
vehicles=['Honda motocyle','Audi car','Fenghuang bycycles']
print("\nI would like to own a "+vehicles[0])

-修改、添加和删除元素

• 修改：list_name[index]=new_value
• 添加：

           list_name.append(value)   #在列表末尾添加

           list_name.insert(index,value)     #在列表中插入元素,index可为负数，表示在倒数某元素前插入新元素

• 删除：

           del list_name[index]

           list_name.pop()   #弹出栈顶元素（即删除末尾元素）

           list_name.pop(index)    #弹出指定位置元素

           list_name.remove(value)    #删除某值，只能删除列表中的第一个指定值   #列表长度len(list_name)

def invitation_message(names):
  for name in names:
    print(name.title()+",今天晚上到我家做客");
#3-4
guest_names=['朱守斌','沈康','傅相存']
invitation_message(guest_names)
#3-5
print("\n")
print(guest_names[1]+"今晚没有空")
guest_names[1]="仁波"
invitation_message(guest_names)
#3-6
print("\n我有一个更大的餐桌，所以我想邀请更多的客人")
guest_names.insert(0,"崔强")
guest_names.insert(int(len(guest_names)/2),"傅磊")
guest_names.append("傅勇")
invitation_message(guest_names)
#3-7
print("\n我的餐桌今晚不能按时送达")
while len(guest_names)>2:
 guest_name = guest_names.pop()
 print(guest_name+",非常抱歉，由于我的餐桌今晚不能按时送达，没办法请您来家里做客了，我们改日再约吧。再次致歉！")
print("\n")
for guest_name in guest_names:
 print(guest_name+",我的餐桌不能按时送达，但是您仍在受邀之列，请按时参加!")
while len(guest_names)>0:
 guest_names.pop()
print("")
if len(guest_names)==0:
 print("受邀嘉宾名单被清空")
else:
 print("受邀嘉宾名单未清空") 

3.3 组织列表

-使用sort()对列表进行永久性排序  list_name.sort([reverse=True])

-使用sorted()对列表进行临时排序  sorted(list_name,[reverse=True])

-使用reverse()倒着打印列表  list_name.reverse()  #reverse()方法永久性地修改列表元素的排列顺序

#3-8
scenics=['Himalayas','Great Wall','Fuji','Taj Mahal','Bali']
print("Scenics: "+str(scenics))
print("\nSorted scenics: "+str(sorted(scenics)))
print("\nScenics: "+str(scenics))
print("\nReverse Sorted scenics: "+str(sorted(scenics,reverse=True)))
print("\nScenics: "+str(scenics))
scenics.reverse()
print("\nReverse scenics: "+str(scenics))
scenics.reverse()
print("\nReverse scenics: "+str(scenics))
scenics.sort()
print("\nScenics sort: "+str(scenics))
scenics.sort(reverse=True)
print("\nReverse scenics sort: "+str(scenics))　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

运行结果： 

第四章 操作列表

4.1 遍历列表

for list_name in list_names:

   loop operation   #循环内操作

out loop operation   #循环结束后的系列操作

4.2 缩进

python通过缩进来判断程序的结构

4.3 创建数值列表

-函数range()                                   #range：范围

range(start,end[,step])   #取[start,end)之间的数值，step为可选参数，用于设置步长

#打印1-10之间的奇数
for value in range(1,11,2):
  print(value,end=" ")

运行结果：

 

-函数list()与函数range()

函数list()与range()结合可生成数字列表

print(list(range(1,5)))   #[1,2,3,4]

eg.生成数字1-10的平方值

squares=[]
for i in range(1,11):
  squares.append(i**2)
print(squares)

测试结果： 

-对数字列表进行简单的统计

max(list_name)  #统计最大值

min(list_name)  #统计最小值

sum(list_name)  #统计列表和

-列表解析

列表解析将for循环和创建新元素的代码合并成一行

# 生成数字1-10的平方值
squares=[i**2 for i in range(1,11)]
print(squares)

测试结果： 

4.4 使用列表的一部分

-切片

#注意：以下m、n的值均可以为负值

list_name(m:n)  #输出list列表中[m,n)之间的值

list(m:)  #输出list列表中[m,end]之间的值,

list(:n)  #输出list列表中[start,n]之间的值

-复制列表

new_list=list_name[:]

-元组

不可改变的列表被称为元组，形式上用圆括号括起来而非方括号,如

(1,2,3,4,5)

第五章 if语句

-if语句模型

#elif与else均可以省略

#Python只执行if-elif-else结构中的一个代码块，它依次检查条件测试，直到遇到通过了的条件测试，执行后面的语句。执行完成后，将跳过结构中余下的测试，执行紧跟在结构后面的代码

#如果只执行一个代码块，就使用if-elif-else结构；如果要运行多个代码块，就使用一系列独立的if语句

if conditional_test_1:

    do sth...

elif conditional_test_2:

    do sth...

elif conditional_test_n:

    do sth...

else:

    do sth...

-逻辑表达式

• Python中检查是否相等时区分大小写  #使用函数lower()解决该问题，函数lower()不会改变变量的大小写
• 检查多个条件使用and与or
• 检查列表中是否（不）包含某个值使用（not）in

-if语句与列表

if list_names   #列表中元素不为空时为true

-Python建议，在诸如==、>=和<=等比较运算符两边各添加一个空格

第六章 字典

6.2 使用字典

字典是一系列键-值对，与键相关联的值可以是数字、字符串、列表乃至字典。字典格式如下：

{"key1":"value1","key2":"value2",...,"keyn":"valuen"}

-字典添加键-值对

dictionary_name[key]=value

-访问字典中的值

dictionary_name[key]

-删除键-值对

del dictionary_name[key]  #删除的键-值对永久消失

6.3遍历字典

#遍历key-value值

for key,value in dictionary_name.items()  #key、value可以是任意值

#遍历key值

for key in dictionary_name.keys()  #key值的遍历顺序随机

按顺序遍历字典中的key值

for key in sorted(dictionary_name.keys())

#遍历value值

for value in dictionary_name.values()

去除重复项

for value in set(dictionary_name.values())

6.4 嵌套

字典、列表可以相互嵌套或自嵌套

试一试

#6-1
friend = {
    "first_name":"shen",
    "last_name":"kang",
    "age":30,
    "city":"hangzhou"
}
print("My friend's first name is: "+friend["first_name"].title())
print("My friend's last name is: "+friend["last_name"].title())
print("My friend's age is: "+str(friend["age"]).title())
print("My friend's living city is: "+friend["city"].title())

#6-2
lucky_number = {
 "zhushoubin":18,
 "fuxiangcun":23,
 "shenkang":6,
 "yangrongling":8,
 "qiyandi":1
}
print("\nzhushoubin like the number: "+str(lucky_number["zhushoubin"]))
print("fuxiangcun like the number: "+str(lucky_number["fuxiangcun"]))
print("shenkang like the number: "+str(lucky_number["shenkang"]))
print("yangrongling like the number: "+str(lucky_number["yangrongling"]))
print("qiyandi like the number: "+str(lucky_number["qiyandi"]))

#6-3
dictionary = {
 "print" : "打印",
 "and" : "逻辑与",
 "or" : "逻辑或",
 "**" : "幂运算",
 "+" : "加法运算"
}
print("\nprint:\n\t"+dictionary["print"])
print("and:\n\t"+dictionary["and"])
print("or:\n\t"+dictionary["or"])
print("**:\n\t"+dictionary["**"])
print("+:\n\t"+dictionary["+"])

#6-4
print("")
for key,mean in dictionary.items():
 print(key+":\n\t"+mean)

#6-5
river_countries={
 "Nile":"Egypt",
 "Changjiang":"China",
 "Missouri":"America"
}
print("")
for river,country in river_countries.items():
 print("The "+river+" runs through "+country)

print("\nRiver:")
for river in river_countries.keys():
 print(river," ")
 
print("\nCountry:")
for country in river_countries.values():
 print(country," ")

 

#6-6
print("")
members=["fuxiangcun","sunmiaomiao","zhubin","qiyanru","qiyandi"]
for member in members:
 for person in lucky_number.keys():
  if member == person:
   print(person.title()+",thank you for your participation in the survey")
   flag=False
   break
 if member != person:
  print(member.title()+",would you like participation in the survey ")

#6-7
friend2 = {
    "first_name":"yu",
    "last_name":"zhongmin",
    "age":27,
    "city":"xuancheng"
}

friend3 = {
    "first_name":"xu",
    "last_name":"dan",
    "age":33,
    "city":"xiaoxian"
}

friends = [friend1,friend2,friend3]

for friend in friends:
 friend_info(friend)

#6-9
favourite_places_dictionary={
 "yuzhongmin":["yunnan","dali","beijing"],
 "fuxiangcun":["shanghai","sanya",""],
 "zhushoubin":["japan","america"]
}

for person,favourite_places in favourite_places_dictionary.items():
 print("\n"+person.title()+" like places: ",end="")
 for favourite_place in favourite_places:
  print(favourite_place.title(),end=" ")

#6-11
cities={
 "Beijing":{
  "country":"China",
  "population":21730000,
  "fact":"the capital of China"
 },
 "Paris":{
  "country":"France",
  "population":11000000,
  "fact":"romatic capital"
 },
 "New York":{
  "country":"America",
  "pupulation":8510000,
  "fact":"disire city"
 }
}
print("")
for city,describes in cities.items():
 print(city+":")
 for describe,value in describes.items():
  print("  "+describe+": "+str(value))

第七章 用户输入和while循环

7.1 input函数

  #python2.7中使用raw_input()输入

  #python2中也有input()函数，它将用户的输入解读为代码并尝试运行它们

• message=input("description") 
• input输入均为字符串，可用int()函数转换为数字

7.2 while循环

• break continue
• for循环与while循环遍历列表

    for循环与while循环都可以遍历列表，但是for循环中不应修改列表，否则将导致Python难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可以使用while循环

• while循环与列表、字典结合

   while list_name:  #循环不断运行，直到列表为空

   while value in list_name:   #循环不断进行过，判断value是否在list_name中

#7-1
car=input("What car would you want to lease?\n")
print("Let me see if I can find you a "+car)

#7-2
people_number=input("\nHow many people are here,please!\n")
if int(people_number)>8:
 print("I'm very sorry,we have not table!")
else:
 print("Yeah,we hava a table,welcome!")
 
#7-3
number=input("\nPlease input a number\n")
if int(number)%10 == 0:
 print(number+"是10的整数倍")
else:
 print(number+"不是10的整数倍")

#7-4

message = "\nWhat ingredients do you want to add in pizza?\
    +\nYou can input 'q' to end the program\n"
while True:
 ingredient=input(message)
 if ingredient != 'q':
  print("Ok,we will add "+ingredient+" in your pizza")
 else:
  break

#7-5

message="\nHow old are your?"\
       +"\nYour can enter 'q' to end the progress!\n"
age = input(message)
while age != "q":
 if age.isdigit():
  if int(age) > 12:
   print("The ticket is 12 dollars")
  elif int(age) > 3 and int(age) <= 12:
   print("The ticket is 10 dollars")
  elif int(age) <= 3 and int(age) > 0:
   print("Baby are free")
  else:
   print("Print wrong!")
 else:
  print("Print wrong!")
 if age != 'q':
  age = input(message) 

#7-8
sandwich_orders=["hardark","jeokea","pastrami","oswere","pastrami","opds","pastrami"]
finished_sandwich=[]
while sandwich_orders:
 sandwich = sandwich_orders.pop()
 print("I made your "+sandwich+" sandwich")
 finished_sandwich.append(sandwich)
print("\nI have made these sandwich:")
for sandwich in finished_sandwich:
 print(sandwich,end=" ")

#7-9
print("\n")
while "pastrami" in finished_sandwich:
 finished_sandwich.remove("pastrami")
for sandwich in finished_sandwich:
 print(sandwich,end=" ")

第八章 函数

8.1 函数编写指南

• 应给函数指定描述性名称，且只在其中使用小写字母和下划线
• 每个函数都应包含简要阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字符串格式

    def function_name():

    """

        annotation

        ...

    """

    function_body...

• 给形参指定默认值时，等号两边不要有空格

    def function_name(parameter_0,parameter_1='default value')

• 定义函数时，如果形参很多，长度过长，可在函数定义中输入左括号按回车键，并在下一行按2次Tab键，从而将形参列表和只缩进一层的函数体区别开来

    def function_name(

            parameter_0,parameter_1,parameter_2,

            parameter_3,...,parameter_n):

        function body...

• 建议在相邻的函数之间使用两个空行将其隔开

8.2 定义函数

    def function_name(parameter_name1,parameter_name2,...,parameter_namen):  #参数可以为空

        funciton_body

    function_name(parameter_value1,parameter_value2,...,parameter_valuen)  #调用函数体

8.3 参数类型

• 位置实参
• 关键字实参  传递给函数的名称-值对，可直接在实参中将名称和值关联起来

        function_name(parameter_name1=parameter_value1,parameter_name2=parameter_value2,...,parameter_namen=parameter_valuen)

• 默认值  编写函数时，可给每个形参指定默认值。当显式的给指定默认值的形参提供实参时，Python将忽略这个形参的默认值

           使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的形参

8.4 返回值

• 在函数中，可以使用return语句将值返回到调用函数的代码行
• 返回简单值
• 可使用默认值（空字符串）让实参变成可选的

        def function_name(parameter_name1,parameter_name2,...,parameter_namen=''):

            ...

            if parameter_namen:   #Python将非空字符串解释为True

               ...

            else:

               ...

            ...

• 返回字典、列表
• 禁止函数修改列表  使用列表实参的副本

        """

            虽然向函数传递列表的副本可以保留原始列表的内容，但除非有充足的理由这样做，否则还是传递原始列表——避免函数花时间和内存创建副本，从而降低了效率，在处理大型列表时尤其如此

        """

        function_name(function_value[:])  

8.5 传递任意数量的参数

• 传递任意数量的实参

        """

          形参名*parameter_name中的星号让Python创建一个名为parameter_name的空元祖，并将收到的所有值都封装到这个元组中

          如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后

        """

        def function_name(*parameter_name):

            ...

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

        def function_name(**parameter_name):

           ...

8.6 将函数存储在模块中

• 导入整个模块

        import module_name [as alias]

        module_name.function_name()   #添加别名后可以使用 alias.function_name

• 导入特定的函数

        from module_name import function_name [as alias]

        fuction_name()    #alias()

        #导入模块中的多个函数

        from module_name import function_name1,function_name2,...,function_namen

        #导入模块中的所有函数

        from module_name import *

#8-1
def display_message():
 print("I will learn Function in this lesson")

display_message()

#8-2
def favorite_book(title):
 print("One of my favorite books is "+title)

favorite_book("Alice in wonderland")

#8-3
def make_shirt(size,word):
 print("The T-shirt size is "+size+" and the word on the T-shirt is \""+word+"\"")

make_shirt("XXL","I love my motherland!")

#8-4
def make_shirt(size,word="I love Python"):
 print("The T-shirt size is "+size+" and the word on the T-shirt is \""+word+"\"")

make_shirt("XXL")
make_shirt("XL")
make_shirt("M","I love Java") 

#8-5
def describe_city(city,country="China"):
 print(city+" is in "+country)


describe_city("Beijing")
describe_city("Shanghai")
describe_city("New York","America")

#8-6
def city_country(city,country):
 return "\""+city+","+country+"\""

print(city_country("Santiago","Chile"))
print(city_country("Tokyo","China"))
print(city_country("Beijing","China"))

#8-7
def make_album(singer,album_name):
 album = {"singer":singer,"album_name":album_name}
 return album

print(make_album("Join","看我72变"))
print(make_album("Jay Chou","依然范特西"))
print(make_album("Andy","Everyone is NO.1"))

#8-8
message = "\n请输入专辑的歌手和名称"
message += "\n您可以随时输入q键取消该操作"
while True:
 print(message)
 singer = input("请输入歌手名: ")
 if singer == "q":
  break
 else:
  album_name = input("请输入专辑名: ")
  if album_name == "q":
   break
  else:
   album={"singer":singer,"albume_name":album_name}
   print(album)

#8-9
magacians=["大卫·科波菲尔","刘谦","傅琰东","刘世杰"]

def show_magicians(names):
 for name in names:
  print(name)

show_magicians(magacians)

#8-10

def make_great(names):
 i = 0
 while i < len(names):
  names[i] = "著名的魔术师："+names[i]
  i += 1

make_great(magacians)
show_magicians(magacians)

#8-11
def make_great(names):
 i = 0
 great_magacians = []
 while names:
  great_magacians.append("伟大的魔术师:" + names.pop())
 return great_magacians

show_magicians(make_great(magacians[:]))
show_magicians(magacians)

#8-12
def make_pizza(*toppings):
 print("\nMake pizza for this toppings:")
 for topping in toppings:
  print("-"+topping)

make_pizza("Dried yeast")
make_pizza("Dried yeast","One egg","green pepper")
make_pizza("Carrot","Onion","Sausage") 

#8-13 
def build_profile(first_name,last_name,**introduction): 
 person={} 
 person["first_name"] = first_name 
 person["last_name"] = last_name 
 for key,value in introduction.items(): 
  person[key] = value 
 return person 
  
myself = build_profile("Dave","Fu",hometown = "Anhui",Colledge="Huaibei normal university", 
major = "Computer science and technology") 
print(myself)

#8-14 
def make_car(manufacturer,production_place,**introduction): 
 car = {} 
 car["manufacturer"] = manufacturer 
 car["production_place"] = production_place 
 for key,value in introduction.items(): 
  car[key] = value 
 return car

car1 = make_car("subaru","outback",color="blue",tow_package=True) 
print(car1)

第九章 类

9.1 类编码风格

• 类名采用驼峰命名法——类名中的每个单词的首字母大写
• 每个类后面均应包含一个文档字符串
• 可使用空行来组织代码，但不要滥用。类中可使用一个空行来分隔方法，模块中可使用两个空行来分隔类
• 需要同时导入标准库中的模块和自定义模块时，先导入标准库中的模块，再隔一个空行导入自定义模块

9.2 类的创建和使用

class Dog():
 def __init__(self, name, age, color=''):
  self.name = name
  self.age = age
  if color:
   self.color = color
  else:
   self.color = "red"
 
 def sit_down(self):
  print(self.name + "is sitting down now!")
 
 def roll_over(self):
  print(self.name + "is roll over now!")
 
 def desc(self):
  print("My dog's name is "+self.name+", it's " +str(self.age)+" years old!, it's "+ self.color)

my_dog = Dog("Lighting",5)
my_dog.sit_down()
my_dog.roll_over()
my_dog.desc()
print(my_dog.name)

• Python中的类名首字母大写，类定义中的括号是空的（Python2中，括号中为object）
• 类中的函数称为方法，包括Python默认方法与普通方法（或自定义方法）
• __init__()为Python中的默认方法，每次创建实例时都会默认调用该方法。该方法中，开头和末尾均有2个下划线
• __init__()中的形参self必不可少，且必须位于其它参数的前面。self默认指向实例本身的引用，让实例能够访问类中属性和方法。每个与类相关联的方法调用都自动传递实参self
• 以self为前缀的变量可供类中的所有方法使用，还可以通过类中的任何实例来访问这些变量。可通过实例访问的变量称为属性

9.3 使用类和实例

class Dog():
 def __init__(self, name):
  self.name = name
  self.age = 0
 
 def update_age(self, age_update):
  if age_update < self.age:
   print("年龄不能减小")
  else:
   self.age += self.age
   print("年龄:"+str(self.age))
 
 def increment_age(self, age_increment):
  self.age += age_increment
  print("年龄:"+str(self.age))
 
 def desc_age(self):
  print(self.name + "的年龄为："+str(self.age))
  
my_dog = Dog("lighting")
my_dog.desc_age()
my_dog.increment_age(1)
my_dog.desc_age()
my_dog.update_age(0)
my_dog.desc_age()
my_dog.update_age(2)
my_dog.desc_age()

• 类中的每个属性都必须有初始值，某些情况下，可在__init__()方法中直接指定某属性的初始值，此时无需包含为它提供初始值的形参
• 修改属性的值

1. 直接修改属性的值
2. 通过方法修改属性的值
3. 通过方法对属性的值进行递增

9.4 继承

示例：
class Car():
 def __init__(self, make, model, year):
  self.make = make
  self.model = model
  self.year = year
  #里程计读数
  self.odometer_reading = 0

 def get_descriptive_name(self):
  print(self.model+" "+self.make+" "+str(self.year)+" "+str(self.odometer_reading))

 def read_odometer(self):
  print("This car has "+str(self.odometer_reading)+" miles on it\n")

 def update_odometer(self, mileage):
  if mileage < self.odometer_reading:
   print("You can't roll back the odometer!")
  else:
   self.odometer_reading = mileage

 def increment_odometer(self, miles):
  self.odometer_reading += miles

class EletricCar(Car):
 def __init__(self, make, model, year, electric_quantity ):
  super().__init__(make, model, year)
  self.electric_quantity = electric_quantity

 def get_descriptive_name(self):
  print(self.model+" "+self.make+" "+str(self.year)+" "+str(self.odometer_reading)+" "+str(self.electric_quantity)+"% electric_quantity")
  

my_car = EletricCar("tesla", "model s", 2017, 100)
my_car.get_descriptive_name()
my_car.read_odometer()

• 一个类继承另一个类时，将自动获得另一个类的属性和方法；原有的类称为父类，继承的类称为子类
• 子类__init__()方法继承父类的__init__()方法： super().__init__()
• 创建子类时，父类必须包含在当前文件中，且位于子类前面
• 定义子类时，必须在括号中指定父类的名称

9.5 导入类

• 导入单个类  from module_name import class_name
• 导入多个类  from module_name import class_name1, class_name2, ...
• 导入模块中的所有类  from module_name import *
• 导入模块    import module_name

9.6 Python标准库

eg. from collections import OrderDict   #导入有序字典

#9-1
class Restaurant():
 #餐款名称  烹饪类型
 def __init__(self, restaurant_name, cuisine_type):
  self.restaurant_name = restaurant_name
  self.cuisine_type = cuisine_type
 
 def describe_restaurant(self):
  print("The restaurant's name is "+self.restaurant_name+" and the cuisine type is "+self.cuisine_type)
 
 def open_restaurant(self):
  print("The restaurant " +self.restaurant_name+" is opening now")
  
restaurant = Restaurant("重庆火锅","川菜")
print("The restaurant name is "+restaurant.restaurant_name)
print("The restaurant cuisine type is "+restaurant.cuisine_type)
restaurant.describe_restaurant()
restaurant.open_restaurant()

#9-2
restaurant1 = Restaurant("贡院蜀楼","川菜")
restaurant2 = Restaurant("皖南水乡","徽菜")
restaurant3 = Restaurant("忘湘园","湘菜")
restaurant1.describe_restaurant()
restaurant2.describe_restaurant()
restaurant3.describe_restaurant()

#9-3
class User():
 def __init__(self, first_name, last_name, sex, age, job):
  self.first_name = first_name
  self.last_name = last_name
  self.sex = sex
  self.age = age
  self.job = job

 def describe_user(self):
  introduction = self.first_name+"·"+self.last_name
  if self.sex == "m":
   introduction =introduction + " is a man and he is "+str(self.age)+" years old, his job is "+self.job
  else:
   introduction =introduction + " is a woman and she is "+str(self.age)+" years old, her job is "+self.job
  print(introduction)
 
user1 = User("守兵", "朱", "m", 31, "技术员")
user2 = User("相存", "傅", "w", 32, "预算员")
user1.describe_user()
user2.describe_user() 

#9-4
class Restaurant():
 #餐款名称  烹饪类型
 def __init__(self, restaurant_name, cuisine_type):
  self.restaurant_name = restaurant_name
  self.cuisine_type = cuisine_type
  self.number_served = 0
 
 def describe_restaurant(self):
  print("The restaurant's name is "+self.restaurant_name+" and the cuisine type is "+self.cuisine_type)
 
 def open_restaurant(self):
  print("The restaurant " +self.restaurant_name+" is opening now")
  
 def set_number_served(self, number_served):
  if self.number_served > number_served:
   print("服务人数不能减少")
  else:
   self.number_served = number_served
  
 def increment_number_served(self, increment_number_served):
  self.number_served += increment_number_served
 
restaurant = Restaurant("重庆火锅","川菜")
restaurant.set_number_served(10)
print("服务人数: "+str(restaurant.number_served))
restaurant.increment_number_served(13)

#9-5
class User():
 def __init__(self, first_name, last_name, sex, age, job):
  self.first_name = first_name
  self.last_name = last_name
  self.sex = sex
  self.age = age
  self.job = job
  self.login_attempts = 0

 def describe_user(self):
  introduction = self.first_name+"·"+self.last_name
  if self.sex == "m":
   introduction =introduction + " is a man and he is "+str(self.age)+" years old, his job is "+self.job
  else:
   introduction =introduction + " is a woman and she is "+str(self.age)+" years old, her job is "+self.job
  print(introduction)
 
 def increment_login_attempts(self):
  self.login_attempts += 1
 
 def reset_login_attempts(self):
  self.login_attempts = 0
 
  
user = User("守兵", "朱", "m", 31, "技术员")
user.increment_login_attempts()
user.increment_login_attempts()
print("登录次数："+str(user.login_attempts))
user.reset_login_attempts()
print("登录次数："+str(user.login_attempts))

#9-6
class Restaurant():
 #餐款名称  烹饪类型
 def __init__(self, restaurant_name, cuisine_type):
  self.restaurant_name = restaurant_name
  self.cuisine_type = cuisine_type
  self.number_served = 0
 
 def describe_restaurant(self):
  print("The restaurant's name is "+self.restaurant_name+" and the cuisine type is "+self.cuisine_type)
 
 def open_restaurant(self):
  print("The restaurant " +self.restaurant_name+" is opening now")
  
 def set_number_served(self, number_served):
  if self.number_served > number_served:
   print("服务人数不能减少")
  else:
   self.number_served = number_served
  
 def increment_number_served(self, increment_number_served):
  self.number_served += increment_number_served
 
restaurant = Restaurant("重庆火锅","川菜")
restaurant.set_number_served(10)
print("服务人数: "+str(restaurant.number_served))
restaurant.increment_number_served(13)

class IceCreamStand(Restaurant):
 def __init__(self, restaurant_name, cuisine_type, flavors):
  super().__init__(restaurant_name, cuisine_type)
  self.flavors = flavors
 
 def describe_flavors(self):
  print("冰激凌口味："+str(self.flavors))

flavors = ['巧克力','奶油','抹茶','香草','香芋','咖啡','树莓','芒果','绿茶','朗姆','橘子']
ice_cream_stand = IceCreamStand("冰激凌小店","冷饮",flavors)
ice_cream_stand.describe_flavors()

#9-7
class User():
 def __init__(self, first_name, last_name, sex, age, job):
  self.first_name = first_name
  self.last_name = last_name
  self.sex = sex
  self.age = age
  self.job = job
  self.login_attempts = 0

 def describe_user(self):
  introduction = self.first_name+"·"+self.last_name
  if self.sex == "m":
   introduction =introduction + " is a man and he is "+str(self.age)+" years old, his job is "+self.job
  else:
   introduction =introduction + " is a woman and she is "+str(self.age)+" years old, her job is "+self.job
  print(introduction)
 
 def increment_login_attempts(self):
  self.login_attempts += 1
 
 def reset_login_attempts(self):
  self.login_attempts = 0
 
  
user = User("守兵", "朱", "m", 31, "技术员")

class Admin(User):
 def __init__(self, first_name, last_name, sex, age, job, privileges):
  super().__init__(first_name, last_name, sex, age, job)
  self.privileges = privileges
 
 def show_privileges(self):
  print("管理员权限: "+str(self.privileges))

privileges = ["can add post", "can delete post", "can ban user"] 
admin = Admin("守兵", "朱", "m", 31, "技术员",privileges)
admin.show_privileges()

#9-8
class User():
 def __init__(self, first_name, last_name, sex, age, job):
  self.first_name = first_name
  self.last_name = last_name
  self.sex = sex
  self.age = age
  self.job = job
  self.login_attempts = 0

 def describe_user(self):
  introduction = self.first_name+"·"+self.last_name
  if self.sex == "m":
   introduction =introduction + " is a man and he is "+str(self.age)+" years old, his job is "+self.job
  else:
   introduction =introduction + " is a woman and she is "+str(self.age)+" years old, her job is "+self.job
  print(introduction)

 def increment_login_attempts(self):
  self.login_attempts += 1
 
 def reset_login_attempts(self):
  self.login_attempts = 0

user = User("守兵", "朱", "m", 31, "技术员")

class Privilege():
 def __init__(self, privileges):
  self.privileges = privileges
 
 def show_privileges(self):
  print("管理员权限: "+str(self.privileges))

class Admin(User):
 def __init__(self, first_name, last_name, sex, age, job, privileges):
  super().__init__(first_name, last_name, sex, age, job)
  self.privileges = privileges

privileges = Privilege(["can add post", "can delete post", "can ban user"])
admin = Admin("守兵", "朱", "m", 31, "技术员",privileges)
admin.privileges.show_privileges()

 

第十章 文件和异常

10.1 读写文件

pi_digits.txt文件
3.1415926535
  8979323846
  2643383279

#读文件
file_name = "pi_digits.txt"
#在当前执行的文件所在的目录中查找指定的文件
with open(file_name) as file_object:   
    contents = file_object.read()
    print(contents.rstrip())    #删除末尾的空白行

#(with代码块内)逐行读取 line可以是任意变量
with open(file_name) as file_object:
    for line in file_object:    
        print(line.rstrip())   
        
with open(file_name) as file_object:
    lines = file_object.readlines()

#(with代码块外)逐行读取
#处理文件内容
pi = ""
for line in lines:    
    pi += line.strip()
    
print("pi = "+pi)
print("pi精度: "+str(len(pi)-2)+"位")

#写文件
file_name = "test.txt"
'''
    文件读取模式：
    -r: 只读
    -w: 写   覆盖写，不可读
    -a: 附加   添加写，不可读
    -r+: 读写  可读可写
'''
with open(file_name,"a") as file_object:
    file_object.write("I love python 才怪！\n")
#    contents = file_object.read()     #报错
    print(contents)

 10.2 异常

python异常继承关系

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

#coding=gbk
#除法
print("输入2个数字,用于除法操作\n")
print("输入'q'以退出\n")

while True:
    firstNum = input("\n输入第一个数字:")
    if firstNum == 'q':
        break
    secondNum = input("\n请输入第二个数字:")
    if secondNum == 'q':
        break
    try:
        answer = int(firstNum)/int(secondNum)
#        print("\n商:"+str(answer))
    except Exception:
#        print("不能除以0")
        pass
    else:
        print("\n商:"+str(answer))    

 获取不同的异常信息

--str(e)：返回字符串类型，只给出异常信息，不包括异常信息的类型，如1/0的异常信息

'integer division or modulo by zero'

--repr(e)：给出较全的异常信息，包括异常信息的类型，如1/0的异常信息

"ZeroDivisionError('integer division or modulo by zero',)"

--e.message：获得的信息同str(e)

--采用traceback模块：需要导入traceback模块，此时获取的信息最全，与python命令行运行程序出现错误信息一致。使用traceback.print_exc()打印异常信息到标准错误，就像没有获取一样，或者使用traceback.format_exc()将同样的输出获取为字符串。你可以向这些函数传递各种各样的参数来限制输出，或者重新打印到像文件类型的对象。