Python 编程：从入门到实战 读书笔记

1、.title()  每个单词首字母大写
     .upper()  所有字母大写
     .lower()  所有字母小写

2、 \t 空白   转义字符只能用在""内
      \n 换行

3、.rstrip() 删除末尾空白
     .lstrip() 删除开头空白
     .strip()  删除两端空白

4、Python将带小数点的数都称为浮点数

5、Python的字符串既可以用单引号也可以用双引号  引号内部还有单引号时，只能用""

str() 可以将非字符串值表示为字符串   //将23转为'23',而不能将abc转为'abc'

Python 用+来合并字符串  "wanyu" + " " + "shuai"

创建多行字符串可以用+=运算符

prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "

6、单行注释 #
     多行注释 """   """  或者  ''' '''

7、[ ] 表示列表  ,分隔其中元素

访问元素   正数 [ ]里从0开始   print(bike[0])
                       倒数           -1          print(bike[-1])

修改元素   指定列表名和元素索引并指定新值      bike[0]='abc'

添加元素   .append()         在末尾添加元素(可创建空列表然后用一系列.append()语句来添加)      bike.append('bcd')
                       .insert( , )         插入元素，需指定新元素的索引与值    bike.insert(0,'cde')

删除元素   del 列表名[]          删除已知位置的列表元素     del bike[0]
                       列表名.pop()         删除索引位置并且能够再次被调用  即弹出效果   bike.pop(2)
                                del和pop()使用后，列表里对应元素均被删除，但是pop()可以继续调用  根据删除后是否还需使用元素选取del和pop
                       列表名.remove()   删除已知元素值             bike.remove('abc')

8、列表排序（注意有的方法，有的是函数）

.sort()                                         永久性按字母顺序排序     bike.sort()
   .sort(reverse=true)                    永久性按字母倒序排序     bike.sort(reverse=true)
   sorted(列表名)                           临时性按字母顺序显示     print(sorted(bike))
   sorted(列表名,reverse=True))   临时性按字母倒序显示     print(sorted(bike,reverse=True))
   .reverse()                                   永久性按列表倒序排序     bike.reverse()

9、len(列表名)    获得列表长度

10、for 变量 in 列表：   for循环，且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") 

print("Thank you everyone, that was a great magic show!")

11、创建数值列表
       第一步：创建了从x到y-1的数，步长为z    range(x,y,z):                          range(1,5,1):

第二步：创建了从x到y-1的列表，步长为z  列表名=list(range(x,y,z))      message=list(range(1,5,1))

列表解析：将for循环和创建新元素的代码合并，并自动添加附加新元素        squares=[value**2 for value in range(1,11)]

12、+ - * /    加减乘除
        %          求模            除2取余可以用来判断奇偶数
        **         表示乘方运算

13、min(列表名)  最小值
       max(列表名)  最大值
       sum(列表名)  求和

14、变量名只包含字母、数字、下划线，但不能以数字打头，不能包含空格、Python关键字和函数名

15、切片：列表名[x:y]   列表里第x+1到第y个元素
          x未写则表示从头开始，y未写则表示到尾结束
          x、y都未写则可用于列表的复制       friends_foods=my_foods[:]     如果只是简单的把一个列表赋给一个变量，就不能得到两个列表
          x若为负数，则为返回列表的后x位

遍历切片只需在切片里用for循环    for player in players[0:3]；

16、()表示元组    即不可变的列表，逗号隔开元素,访问元素与列表相同
                  遍历元组则用for循环        for bike in bikes:
                  元组的元素不可以被修改，但是整个元组可以被重新赋值       bikes=(200,100)   bikes=(50,100)

17、代码格式PEP8     https://www.python.org/dev/peps/pep-0008/
                     缩进每次用4个空格
                     利用空行让代码看上去整洁
                     ==、>=、<= 两边各添加一个空格
                     包含多个函数时，建议每个函数之间空2行

18、if条件语句    ①if + 条件:
                                else:
                            ②if + 条件:
                    　　     elif + 条件:
                    　　     else:

注意（1）冒号：不能丢
               （2）if、else后面的语句换行写时要缩进
               （3）elif可以有多句，else可以没有
               （4）当需要执行多个代码块，也可以用多个if语句

requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
if 'mushrooms' in requested_toppings:
    print()     #省略没写
elif 'french fries' in requested_toppings:
    print()
elif 'extra cheese' in requested_toppings:
    print()

第一个mushrooms检测通过了，程序将跳过下面的elif结构，不再检查其他内容，所以if-elif-else结构仅适用于只有一个条件满足的情况

而想要检测多个条件满足的情况应该用多个if语句

requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
if 'mushrooms' in requested_toppings:
    print()     #省略没写
if 'french fries' in requested_toppings:
    print()
if 'extra cheese' in requested_toppings:
    print()

19、=  赋值
       == 等于   检查字符是否相等时，会区分大小写，若要不区分的话，可使用.lower()
       != 不等于
       and 与
       or  或
       in  包含在列表中
       not in  未包含在列表中

>>>bikes=['a','b','c']
>>>'a' in bikes
>>>True

if + 列表名：    如果列表不为空，则会返回True;如果列表为空，返回值为False

20、布尔表达式  True / False

21、字典是放在{}里的一系列键值对，键需要加''而值不一定  键值之间用:隔开  键值对之间用,隔开
        字典名={'键':值}    alien_0={'color':'gerrn','points':5}

访问字典值  可依次指定字典名和放在[]的键   即  字典名['键']     print(alien_0['color'])

添加键值对  依次指定字典名、[]括起来的键和关联的值   即  字典名['键']=值
                Python不关心键值对的顺序，只关心键和值的对应关系
                alien_0['x_position']=0
                alien_0['y_position']=25
                很多时候是先建立一个空字典，再分别添加键值对       字典名={}

修改字典值  指定字典名、[]括起来的键和关联的新值   即  字典名['键']=新值     alien_0['color']='yellow'

删除键值对  del 字典名['键']       del alien_0['color']

较长的列表和字典，可以将键值对放在不同的行里，注意行前缩进

alien_0={
     'color':'gerrn',
     'points':5,
     'head':'big',
     'phil':'python'}

遍历字典中键值对   for  变量名1,变量名2 in 字典名.items()：   for循环将每个键值对存储到指定的变量中,变量1为键，变量2为值

for key,value in user_0.items():
    print("\nKey: " + key)
    print("Value: " + value)

遍历字典中键       for  变量名 in 字典名.keys()       for name in user_0.keys():
     .keys()方法实质上是返回一个列表，包含字典的所有键，因此其还可以用于判断某值是否在字典的键里

if 'erin' not in alien_0.keys():
    print()

按顺序获取返回元素可在for里调用sorted()函数         for key in sorted(alien_0.keys()):

遍历字典中值       for  变量名 in 字典名.values()        for name in user_0.values():

如需去掉重复值，则在for里调用set函数                    for name in set(user_0.values()):

关于键值重复的问题，键从逻辑上讲是不能重复的，但重复了不会报错，只会认为是对键重新赋值，值可以重复

22、print打印的内容较长时，也可以将内容分行写以获得整洁的代码界面

23、在列表里存储字典    将多个字典放入列表中           aliens=[alien_0,alien_1,alien_2]
       在字典里存储列表    即 键 对应的 值 可以为列表

pizza = {
    'crust': 'thick',
    'toppings': ['mushrooms', 'extra cheese'],
    }

在字典里存储字典    即键对应的值可以为字典

users = {'aeinstein': {'first': 'albert',
                       'last': 'einstein',
                       'location': 'princeton'},
         'mcurie': {'first': 'marie',
                    'last': 'curie',
                    'location': 'paris'},

24、 input()函数用来等待用户输入，括号里可以为字符串变量也可以为字符串。其返回的值永远是用户输入的字符串
        input("\nTell me something, and I will repeat it back to you: ")

int()函数可以将input的字符串转为数值，以达到相应的要求

age=input("How old are you ?")
year=int(age)

25、用好标志（True,False）可以简化判断、循环语句

26、while循环：while 语句 :
        break终止整个循环，continue退出当前循环，返回到循环开头
        注意避免无限循环，可以用ctrl+c退出

27、while 列表:   或   while 变量 in 列表:  对列表的循环

while unconfirmed_users:
    current_user = unconfirmed_users.pop()
while 'cat' in pets:
    pets.remove('cat')

28、def 函数名(参数):    函数的语句要缩进

def describe_pet(pet_name, animal_type='dog'):
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")

传递实参分 位置实参 和 关键字实参
    位置实参       describe_pet('harry', 'hamster')
    关键字实参   describe_pet(animal_type='hamster', pet_name='harry')   关键字实参即指定实参的形参类型，所以就无需区分位置

编写函数时，还可以给某一形参给定默认值，在调用函数时，就无需再指定此形参的实参，函数会使用默认值。
    注意：在编写函数时，形参列表中必须先列出没有默认值的形参，再列出有默认值的形参。
          在指定默认值时，等号两边不要有空格，调用时也是如此，当然如果不适用默认值，那么就可以重新传递新的实参

def describe_pet(pet_name, animal_type='dog'):
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(pet_name='willie')     #使用默认值
describe_pet('harry', 'hamster')    #不使用默认值，传递位置实参
describe_pet(pet_name='harry', animal_type='hamster')   #不使用默认值，传递关键字实参
describe_pet(animal_type='hamster', pet_name='harry')   #不使用默认值，传递关键字实参

有时候需要将函数的实参变成可选的，因为函数的参数并不是所有情况下都需要，这时可以将那个不一定需要的形参设为空，即''，再来个判断语句

def get_formatted_name(first_name,last_name,middle_name='')
    if middle_name:
        print()
    else:
        print()        

函数形参过多时，导致代码长度超出80，不符合PEP8，可将   形参都放到下一行，甚至下几行，要注意缩进(2个tab)

def fuction_name(
        a,b,c,
        d,e.f):
    fuction body...

函数的返回值可以任何类型的值  结构为 return 返回内容
    返回简单值  return full_name.title()

返回字典

def build_person(first_name, last_name, age=''):
    person = {'first': first_name, 'last': last_name}
    return person

函数的参数也可以是一个列表，即传递列表

def greet_users(names):
    for name in names:
        msg = "Hello, " + name.title() + "!"
        print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)

有时候需要禁止函数修改列表，则传递列表时可以利用切片传递列表的副本，即  function_name(list_name[:])   这样就可以保留原始列表的内容
    除非有充分理由使用副本，否则少使用，提高效率。函数使用现成列表可以避免浪费时间和内存创建副本，尤其处理大型列表时

函数传递任意数量的实参，可将函数的形参设为 *名称         def pizza(*pizzas)：
    这样就创建了一个名为pizzas的空元组，函数能将所有收到的实参都放进这个元组里

想让函数接受不同类型的实参时，必须将任意数量实参放到最后，Python将先匹配位置实参和关键字实参，余下的实参将收集到最后一个形参中去

def make_pizza(size,*toppings)
    print()
make_pizza(16,'mushrooms','cheese')

使用任意数量的关键字实参，可传递给函数键值对，将形参设为**名称，再利用for循环

def build_profile(first, last, **user_info):
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile

29、导入模块，在当前.py的目录中再创建一个.py的文件，里面可以放函数，然后在当前py里导入这个模块,语句为import  所有的import语句放在开头
       再调用函数时，其前面还需要加上模块名，即   模块名.函数名
       比如  pizza.py文件里定义了一个函数   def do_pizza(size, *toppings):   （内容此处省略）
       则在pizza.py文件的目录里的另一个文件make_pizza里可以导入模块

import pizza
pizza.do_pizza()

也可以导入指定模块的指定函数,格式为       from module_name import function_0,function_1
      使用*可以导入模块中的所有函数                 from module_name import *
      这样在调用模块中的函数时就无需写模块.函数，直接调用函数名，但一般不推荐使用，因为如果不是自己写的模块，可能会有很多函数重名

as可以给指定模块和函数起别名，就可以用别名来调用函数和模块
      from module_name import function_name as fn
      import module_name as mn

30、类
       创建类   class 名称():         class Dog():         注意：名称的首字母要大写
       类里可以定义不同的方法   def 方法名称():
       第一个定义的方法一般是_init_()   当我们使用类时，Python会自动运行它，注意其名称，且其形参第一个为self，之后为其他信息
       且用句点表示法获取值

def __init__(self, name, age):
    self.name = name
    self.age = age

之后可以定义其他的方法，如果不需要其他的信息，方法的形参只有一个self

def sit(self):
    print(self.name.title() + " is now sitting.")
def roll_over(self):
    print(self.name.title() + " rolled over!")

根据类创建实例,Python将使用实参调用类中的方法_init_()创建表示特定的实例，并自动返回给一个变量，这个变量可以自己设置
    my_dog = Dog('willie', 6)

创建完之后，可以访问实例的属性，其为句点表示法 变量.属性

print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")

还可以调用类中定义的方法，仍然为句点表示法

my_dog = Dog('willie', 6)
my_dog.sit()

当需要给某个属性添加默认值时，就无需包含为它提供初始值的形参

class Car():
    def __init__(self, manufacturer, model, year):
        self.manufacturer = manufacturer
        self.model = model
        self.year = year
        self.odometer_reading = 0    #此值设为默认值，所以在设置形参时没有设置这个量

有时候需要修改属性的值，有三种方法
    （1）直接修改属性的值，通过实例直接访问（基于上面定义过的方法举例）

my_new_car=Car('audi','',2016)
my_new_car.odometer_reading=23      #这样就直接修改了默认值0

（2）通过方法修改属性的值  即定义一个修改属性的方法

def update_odometer(self,mileage):
    self.odometer_reading = mileage
my_new_car.update_odometer(23)      #也修改了默认值0

（3）通过方法对属性的值进行递增/递减

def increment_odometer(self,miles)
    self.odometer_reading += miles
my_new_car.increment_odometer(100)  #通过+=改变了属性值

继承
     编写一个类的时候可以继承另一个类，原先的类称为父类，新的类称为子类。子类可以自动获得父类的全部属性和方法，同时还可以定义自己的属性和方法
     创建子类时，父类必须在此文件中，且必须在子类的前面   格式为   class 子类名(父类名):

class Car():    #省略了父类的内容
class ElectricCar(Car)：

子类需要写继承父类属性的语句（举例接着上面的内容）   即调用super()函数

class Car():    #省略了父类的内容
class ElectricCar(Car)：
    def __init__(self, manufacturer, model, year):      #初始化父类的属性
    super().__init__(manufacturer, model, year)     #此行代码调用父类的方法_init_()

super()函数调用之后，可添加新属性和新方法

class Car():    #省略了父类的内容
class ElectricCar(Car)：
    def __init__(self, manufacturer, model, year):      #初始化父类的属性
        super().__init__(manufacturer, model, year)     #此行代码调用父类的方法_init_()
        self.battery_size = 70                         #添加了子类的新属性
    def describe_battery(self):                         #添加了新方法
        print()

父类的方法没有任何用处时，你可以重写它。语句就是普通的定义

class ElectricCar(Car)：
    def fill_gas_tank():                               #重新定义父类的方法
        print()

可以定义一个新的类，作为另一个类的一个属性

class Battery():
    def __init__(self, battery_size=60):
        self.battery_size = battery_size
    def describe_battery(self):
        print("This car has a " + str(self.battery_size) + "-kWh battery.")
class ElectricCar(Car):
    def __init__(self, manufacturer, model, year):
        super().__init__(manufacturer, model, year)
        self.battery = Battery()                      #属性是一个类
my_tesla = ElectricCar('tesla','model s',2016)
my_tesla.battery.describe_battery()                   #调用实例的battery属性里的方法

导入类，将一个类写在一个.py文件里，在另一个.py文件里导入这个类  格式为  from 模块名 import 类名
    举例   Car类在car.py里，则在my_car.py里导入Car可写为  from car import Car
    可以导入一个模块的多个类    from 模块名 import 类名1,类名2     在调用类时，直接建立实例就可以，不需要其他格式

当然也可以导入整个模块，格式为  import 模块名
    但是在建立实例时，就需要用点号表达式   my_beetle = car.Car()

编写类时，应该写好注释
    类中，用一个空行分隔方法
    模块中，用两个空行分隔类
    导入模块时，先写导入标准库的语句，再写导入自己编写的模块的语句

31、文件
       读取文件 with open('路径') as 变量:

with open('pi_digits.txt') as file_object:    #关键字with在不再需要访问文件后将文件关闭
    contents = file_object.read()             #方法.read()读取文件的全部内容
    print(contents)

上例open()函数里只有文件名，是因为其和.py文件在相同目录。()里也可以放文件的绝对路径
    但绝对路径在windows系统里，是用\隔开，例如D:\code_work\Python\pi_digits.txt
    过长的路径影响美观，所以可以将其放在一个变量里

file_path = 'D:\code_work\Python\pi_digits.txt'    #注意一定是字符串
with open(file_path) as file_project:

逐行读取文件只需使用for循环将每一行的内容放到变量中即可
    for line in file_object:           #每一行的内容就放到了line中

使用关键字with时，open()返回的文件对象只能在with代码块中使用，要想在代码块外访问文件内容，可将文件的各行存储在一个列表里，并在代码块外使用该列表

with open('pi_digits.txt') as file_object:
    lines = file_object.readlines()           #用方法readlines()将每一行的内容放到了lines列表中
for line in lines:
    print()

读取文本文件时，Python 将其中所有内容都解读为字符串，如果要作为数值使用，就必须用int()或者float()转换

写入文件格式为  with open(文件,‘w’) as 变量:               'r' 读取模式 'w'写入模式 'a'附加模式  'r+' 读取和写入模式   若省略模式参数，则默认为读取模式
    如果写入的文件不存在，Python将自动创建它。如果写入的文件存在，那么将在返回对象前清空文件
    写入的语句用放方法.write()

file_path = 'D:\code_work\Python\pi_digits.txt'
with open(file_path,'w') as file_object:
    file_object.write('I lOVE YOU')                   #如果要写入多行语句，则需要添加换行符号

'w'写入模式将原文件内容清空，写入新的语句，如果不想清空原文件，则可以使用'a'附加模式，写入的内容将会被添加到文件末尾

with open('programming.txt', 'a') as file_object:
    file_object.write("I also love finding meaning in large datasets.\n")

32、异常
    当发生错误时，如果编写了处理问题的代码，程序将继续运行，如果没有，程序将会停止，且会返回一个traceback
    处理问题的代码块为  try-except
    print(5/0)  将会返回一个traceback，里面的ZeroDivisionError则是一个异常对象，那么就要对异常进行处理

try:
    print(5/0)
except ZeroDivisionError:
    print("you can't divide by zero !")

找不到文件的异常对象为FileNotFoundError

filename = 'alice.txt'try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except FileNotFoundError as e:
    msg = "Sorry, the file " + filename + " does not exist."
    print(msg)

try-except-else 代码块，适用于包含正常情况发生的代码

while True:
    first_number = input("\nFirst number: ")
    if first_number == 'q':
        break
    second_number = input("Second number: ")
    try:
        answer = int(first_number) / int(second_number)
    except ZeroDivisionError:
        print("You can't divide by 0!")
    else:
        print(answer)

可以将try-except-else结构写为函数，多处使用
    如果希望程序在碰到异常对象时一声不吭，则可以在except的语句里写pass，当这种错误发生的时候，既没有traceback，也没有任何输出

while True:
    first_number = input("\nFirst number: ")
    if first_number == 'q':
       break
    second_number = input("Second number: ")
    try:
       answer = int(first_number) / int(second_number)
    except ZeroDivisionError:
        pass
    else:
        print(answer)

33、方法split()以空格为分隔符将字符串分拆为多个部分，并将这些部分都存储到一个列表中

34、模块json能将简单的Python数据结构转储到文件中，并在程序再次运行时加载文件中的数据
        json模块里有json.dump()函数，接受两个实参，要存储的数据和可用于存储数据的文件对象   dump：转储

import json                                   #导入json模块
numbers = [2, 3, 5, 7, 11, 13]                #创建一个数字列表
filename = 'numbers.json'                     #指定所存储的文件名称
with open(filename, 'w') as file_object:      #以写入模式打开文件，让json能够将数据写入其中
    json.dump(numbers, file_object)           #使用json.dump()函数将数字列表存储到文件中

json模块里有json.load()函数，能够加载文件中的数据

import json                                   #导入模块
filename = 'numbers.json'                     #之前写入的文件
with open(filename) as file_object:           #读取模式打开文件
    numbers = json.load(file_object)          #使用ison.load()加载存储在文件里的信息，并将其存储到变量numbers中
print(numbers)

使用json保存用户的数据很方便，便于储存和记忆

import json

def get_stored_username():
    """Get stored username if available."""
    filename = 'username.json'
    try:
        with open(filename) as f_obj:
            username = json.load(f_obj)
    except FileNotFoundError:
        return None
    else:
        return username

def get_new_username():
    """Prompt for a new username."""
    username = input("What is your name? ")
    filename = 'username.json'
    with open(filename, 'w') as f_obj:
        json.dump(username, f_obj)
    return username

def greet_user():
    """Greet the user by name."""
    username = get_stored_username()
    if username:
        print("Welcome back, " + username + "!")
    else:
        username = get_new_username()
        print("We'll remember you when you come back, " + username + "!")

greet_user()

35、重构：将代码分为一系列完成具体工作的函数，使得代码更清晰、更易于理解、更容易扩展

36、测试代码

欢迎阅读，有任何错误可以指出，感谢