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

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

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

 

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

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

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

    返回字典    

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

 

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()函数将数字列表存储到文件中
my_dog = Dog('willie', 6)
my_dog.sit()

 

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

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

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

 

import json                                   #导入模块
filename = 'numbers.json'                     #之前写入的文件
with open(filename) as file_object:           #读取模式打开文件
    numbers = json.load(file_object)          #使用ison.load()加载存储在文件里的信息,并将其存储到变量numbers中
print(numbers)
my_new_car=Car('audi','24',2016)
my_new_car.odometer_reading=23      #这样就直接修改了默认值0

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

 

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

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

 

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

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

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

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

 

def greet_users(names):
    for name in names:
        msg = "Hello, " + name.title() + "!"
        print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)
users = {'aeinstein': {'first': 'albert',
                       'last': 'einstein',
                       'location': 'princeton'},
         'mcurie': {'first': 'marie',
                    'last': 'curie',
                    'location': 'paris'},

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

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

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

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

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

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

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

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

 

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

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

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

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

 

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

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

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

 

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

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

 

 

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

 

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

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

 

 

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

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

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

 

 

 

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

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

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

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

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

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

alien_0={
     'color':'gerrn',
     'points':5,
     'head':'big',
     'phil':'python'}
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!")

 

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

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

8、列表排序(注意有的方法,有的是函数)

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

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

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

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

def fuction_name(
        a,b,c,
        d,e.f):
    fuction body...
file_path = 'D:code_workPythonpi_digits.txt'    #注意一定是字符串
with open(file_path) as file_project:

 

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

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()

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

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

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

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

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

 

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

 

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

 

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

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()
for key,value in user_0.items():
    print("nKey: " + key)
    print("Value: " + value)

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

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

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

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

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

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

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

 

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

 

def update_odometer(self,mileage):
    self.odometer_reading = mileage
my_new_car.update_odometer(23)      #也修改了默认值0
>>>bikes=['a','b','c']
>>>'a' in bikes
>>>True

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

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

36、测试代码

   .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()

 

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

 

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

 

 

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')   #不使用默认值,传递关键字实参

 

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

 

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)

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

def sit(self):
    print(self.name.title() + " is now sitting.")
def roll_over(self):
    print(self.name.title() + " rolled over!")
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()
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)

 

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

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

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

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

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

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

def get_formatted_name(first_name,last_name,middle_name='')
    if middle_name:
        print()
    else:
        print()        
try:
    print(5/0)
except ZeroDivisionError:
    print("you can't divide by zero !")

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

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

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)
class ElectricCar(Car):
    def fill_gas_tank():                               #重新定义父类的方法
        print()

 

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

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

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

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

with open('pi_digits.txt') as file_object:
    lines = file_object.readlines()           #用方法readlines()将每一行的内容放到了lines列表中
for line in lines:
    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属性里的方法

  

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

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

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

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

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

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

 

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

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

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

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

 

20、布尔表达式  True / False

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

 

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

 

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

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

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

 

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

 

 

 

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

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

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

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

10、for 变量 in 列表:   for循环,且for循环后的每一句代码,没有缩进的只执行一次,缩进的重复执行   注意‘:’和缩进        

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

 

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

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

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

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()

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

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

 

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

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

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

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

本文由金沙官网线上发布于编程,转载请注明出处:Python 编程:从入门到实战 读书笔记

您可能还会对下面的文章感兴趣: