Python 编制程序:从入门到实战 读书笔记,python读书笔记

1、.title()  各种单词首字母大写
     .upper()  全部字母大写
     .lower()  全部字母小写

Python 编制程序:从入门到实战 读书笔记,python读书笔记

一、.title()  各个单词首字母大写
     .upper()  全数字母大写
     .lower()  全部字母小写

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

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

四、Python将带小数点的数都称呼浮点数

五、Python的字符串既能够用单引号也足以用双引号 
引号内部还有单引号时,只好用””

     str() 能够将非字符串值表示为字符串  
//将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. "

 

六、单行注释 #
     多行注释 “””   “””  大概  ”’ ”’

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(二)
                               
del和pop()使用后,列表里对应成分均被剔除,不过pop()能够延续调用 
依据删除后是还是不是还需采用要素选择del和pop
                       列表名.remove()   删除已知成分值            
bike.remove(‘abc’)

八、列表排序(注意有的艺术,有的是函数)

   .sort()                                        
永世性按字母逐1排序     bike.sort()
   .sort(reverse=true)                    恒久性按字母倒序排序    
bike.sort(reverse=true)
   sorted(列表名)                           一时性按字母逐1呈现    
print(sorted(bike))
   sorted(列表名,reverse=True))   目前性按字母倒序彰显    
print(sorted(bike,reverse=True))
   .reverse()                                   恒久性按列表倒序排序    
bike.reverse()

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

拾、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!")

 

1一、创立数值列表
       第3步:缔造了从x到y-一的数,步长为z   
range(x,y,z):                          range(一,伍,一):

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

      
列表解析:将for循环和成立新因素的代码合并,并自动增多附加新成分       
squares=[value**2 for value in range(1,11)]

12、+ – * /    加减乘除
        %          求模            除二取余得以用来判定奇偶数
        **         表示乘方运算

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

1四、变量名只包罗字母、数字、下划线,但不能够以数字打头,无法包括空格、Python关键字和函数名

15、切片:列表名[x:y]   列表里第x+一到第y个元素
          x未写则意味着从头开首,y未写则意味着到尾截至
          x、y都未写则可用以列表的复制      
friends_foods=my_foods[:]    
假若只是轻便的把3个列表赋给2个变量,就无法获取五个列表
          x若为负数,则为回去列表的后x位

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

16、()表示元组    即不可变的列表,逗号隔绝成分,访问成分与列表相同
                  遍历元组则用for循环        for bike in bikes:
                 
元组的成分无法被涂改,不过凡事元组能够被另行赋值      
bikes=(200,十0)   bikes=(50,100)

17、代码格式PEP八     https://www.python.org/dev/peps/pep-0008/
                     缩进每趟用6个空格
                     利用空行让代码看上去整洁
                     ==、>=、<= 两边各增加2个空格
                     包括八个函数时,提议各个函数之间空二行

1八、if条件语句    一if + 条件:
                                else:
                            ②if + 条件:
                           elif + 条件:
                           else:

        注意(1)冒号:不能丢
               (贰)if、else前边的讲话换行写时要缩进
               (三)elif能够有多句,else能够未有
               (四)当必要实践八个代码块,也能够用八个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()

        
第3个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

 

二一、字典是投身{}里的一四种键值对,键必要加”而值不必然  键值之间用:隔开 
键值对中间用,隔离
        字典名={‘键’:值}    alien_0={‘color’:’gerrn’,’points’:5}

        访问字典值  可依次钦赐字典名和位于[]的键   即 
字典名[‘键’]     print(alien_0[‘color’])

        加多键值对  依次内定字典名、[]括起来的键和涉嫌的值   即 
字典名[‘键’]=值
                Python不关心键值对的逐条,只关怀键和值的对应关系
                alien_0[‘x_position’]=0
                alien_0[‘y_position’]=25
                许多时候是先创设3个空字典,再分别增多键值对      
字典名={}

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

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

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

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

 

       遍历字典中键值对   for  变量名一,变量名贰 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()):

    
关于键值重复的难点,键从逻辑上讲是不可能再一次的,但再也了不会报错,只会以为是对键重新赋值,值能够重新

 

2二、print打字与印刷的始末较长时,也足以将内容分行写以获得卫生的代码分界面

 

二叁、在列表里积存字典    将八个字典放入列表中          
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'},

 

二4、
input()函数用来等待用户输入,括号里可感到字符串变量也可认为字符串。其归来的值永久是用户输入的字符串
        input(“\nTell me something, and I will repeat it back to you:
“)

        int()函数能够将input的字符串转为数值,以高达相应的需求   

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

二5、用好标记(True,False)能够简化决断、循环语句

26、while循环:while 语句 :
        break终止整个循环,continue退出当前循环,重回到循环起先
        注意制止Infiniti循环,能够用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,不相符PEP八,可将  
形参都放到下壹行,乃至下几行,要留意缩进(1个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

 

2玖、导入模块,在当前.py的目录中再次创下设3个.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 方法名称():
       第3个概念的方式一般是_init_()  
当大家应用类时,Python会自动运转它,注意其名称,且其形参第3个为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    #此值设为默认值,所以在设置形参时没有设置这个量

 

    有时候要求修改属性的值,有三种情势
    (壹)直接修改属性的值,通超过实际例直接待上访问(基于上边定义过的主意比方)

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

 

    (二)通过措施修改属性的值  即定义多少个改变属性的艺术

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

 

    (三)通过措施对质量的值举办递增/递减

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

 

     继承
    
编写3个类的时候能够一而再另二个类,原先的类称为父类,新的类称为子类。子类能够自动获得父类的整特性质和办法,同时还足以定义本身的性质和章程
     创建子类时,父类必须在此文件中,且必须在子类的后边   格式为   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()

 

 

    可以定义多少个新的类,作为另3个类的三个属性

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属性里的方法

    导入类,将八个类写在3个.py文件里,在另三个.py文件里导入这几个类 
格式为  from 模块名 import 类名
    举例   Car类在car.py里,则在my_car.py里导入Car可写为  from car
import Car
    能够导入一个模块的四个类    from 模块名 import 类名一,类名2    
在调用类时,直接构建实例就足以,没有供给任何格式

    当然也得以导入整个模块,格式为  import 模块名
    不过在成立实例时,就需求用点号表明式   my_beetle = car.Car()

    编写类时,应该写好注释
    类中,用3个空行分隔方法
    模块中,用三个空行分隔类
    导入模块时,先写导入标准库的讲话,再写导入自个儿编写的模块的话语

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、重构:将代码分为一文山会海成就具体做事的函数,使得代码更显著、更易于掌握、更易于扩大

3六、测试代码

 

接待阅读,有别的不当能够提议,感激

 

http://www.bkjia.com/Pythonjc/1309013.htmlwww.bkjia.comtruehttp://www.bkjia.com/Pythonjc/1309013.htmlTechArticlePython 编制程序:从入门到实战
读书笔记,python读书笔记 壹、.title() 各种单词首字母大写 .upper()
全数字母大写 .lower() 全体字母小写 二、 \t 空白…

2、 \t 空白   转义字符只可以用在””内
      \n 换行

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

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

伍、Python的字符串既能够用单引号也足以用双引号 
引号内部还有单引号时,只好用””

     str() 能够将非字符串值表示为字符串  
//将二三转为’贰三’,而无法将abc转为’abc’

     Python 用+来归并字符串  “wanyu” + ” ” + “shuai”

     创立多行字符串能够用+=运算符

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

 

陆、单行注释 #
     多行注释 “””   “””  大概  ”’ ”’

7、[ ] 表示列表  ,分隔其10月素

      访问成分   正数 [ ]里从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(二)
                               
del和pop()使用后,列表里对应成分均被去除,可是pop()能够一连调用 
依据删除后是还是不是还需采纳要素选拔del和pop
                       列表名.remove()   删除已知成分值            
bike.remove(‘abc’)

八、列表排序(注意有的艺术,有的是函数)

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

玖、len(列表名)    得到列表长度

拾、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-一的数,步长为z   
range(x,y,z):                          range(一,伍,1):

       第3步:创造了从x到y-一的列表,步长为z 
列表名=list(range(x,y,z))      message=list(range(1,伍,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];

1陆、()表示元组    即不可变的列表,逗号隔断成分,访问成分与列表同样
                  遍历元组则用for循环        for bike in bikes:
                 
元组的因素不可能被修改,可是整个元组能够被再一次赋值      
bikes=(200,拾0)   bikes=(50,100)

17、代码格式PEP八     https://www.python.org/dev/peps/pep-0008/
                     缩进每一趟用伍个空格
                     利用空行让代码看上去整洁
                     ==、>=、<= 两边各拉长八个空格
                     包蕴四个函数时,提出每一种函数之间空贰行

1八、if条件语句    1if + 条件:
                                else:
                            ②if + 条件:
                           elif + 条件:
                           else:

        注意(1)冒号:不能丢
               (贰)if、else前边的口舌换行写时要缩进
               (三)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
                繁多时候是先创制3个空字典,再分别增多键值对      
字典名={}

       修改字典值  钦赐字典名、[]括起来的键和涉嫌的新值   即 
字典名[‘键’]=新值     alien_0[‘color’]=’yellow’

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

       较长的列表和字典,能够将键值对位于分歧的行里,注意行前缩进

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

 

       遍历字典中键值对   for  变量名一,变量名二 in 字典名.items():  
for循环将各样键值对存款和储蓄到钦赐的变量中,变量一为键,变量二为值

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

 

     遍历字典中键       for  变量名 in 字典名.keys()       for name in
user_0.keys():
    
.keys()方法实质上是回去3个列表,包罗字典的全体键,由此其还足以用来决断某值是或不是在字典的键里

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

    
关于键值重复的难点,键从逻辑上讲是不能够再一次的,但再一次了不会报错,只会以为是对键重新赋值,值能够重新

 

2二、print打字与印刷的情节较长时,也足以将内容分行写以博得卫生的代码分界面

 

2叁、在列表里积攒字典    将几个字典放入列表中          
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'},

 

二肆、
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退出当前巡回,再次回到到循环起来
        注意制止Infiniti循环,能够用ctrl+c退出

贰7、while 列表:   或   while 变量 in 列表:  对列表的巡回

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

2八、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’)   关键字实参即钦定实参的形参类型,所以就没有须求区分地点

   
编写函数时,还足以给某1形参给定私下认可值,在调用函数时,就无需再钦赐此形参的实参,函数会采取暗中认可值。
   
注意:在编辑函数时,形参列表中务必先列出从未私下认可值的形参,再列出有暗许值的形参。
         
在钦定默许值时,等号两边不要有空格,调用时也是如此,当然假如不适用私下认可值,那么就足以另行传递新的实参

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,可将  
形参都放到下一行,乃至下几行,要留意缩进(一个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[:])   那样就能够保存原始列表的内容
   
除非有丰盛理由使用别本,不然少使用,升高成效。函数使用现有列表能够幸免浪费时间和内部存款和储蓄器创制别本,特别处理大型列表时

    函数字传送递放4数量的实参,可将函数的形参设为 *名称         def
pizza(*pizzas):
   
那样就创立了二个名称叫pizzas的空元组,函数能将具备接收的实参都放进这一个元组里

   
想让函数接受不相同品类的实参时,必须将随便数量实参放到最后,Python将先相称岗位实参和关键字实参,余下的实参将采访到终极3个形参中去

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

 

2玖、导入模块,在当前.py的目录中再次创下建一个.py的文件,里面能够放函数,然后在日前py里导入那么些模块,语句为import 
全部的import语句放在伊始
       再调用函数时,其前方还亟需增添模块名,即   模块名.函数名
       比如  pizza.py文件里定义了七个函数   def do_pizza(size,
*toppings):   (内容此处省略)
       则在pizza.py文件的目录里的另1个文本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

 

     
之后能够定义别的的不2诀要,假设无需任何的音讯,方法的形参唯有七个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    #此值设为默认值,所以在设置形参时没有设置这个量

 

    有时候供给修改属性的值,有二种方法
    (一)直接改造属性的值,通超过实际例间接待上访问(基于上边定义过的主意举个例子)

my_new_car=Car('audi','24',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

 

    (三)通过艺术对质量的值进行递增/递减

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

 

 

    能够定义四个新的类,作为另一个类的6天性质

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 类名壹,类名2    
在调用类时,直接建设构造实例就足以,无需别的格式

    当然也能够导入整个模块,格式为  import 模块名
    可是在建设构造实例时,就要求用点号表明式   my_beetle = car.Car()

    编写类时,应该写好注释
    类中,用1个空行分隔方法
    模块中,用五个空行分隔类
    导入模块时,先写导入规范库的言语,再写导入自身编排的模块的言辞

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循环将每1行的始末放到变量中就可以
    for line in file_object:           #每壹行的始末就放到了line中

   
使用首要字with时,open()再次回到的文件对象只幸好with代码块中央银行使,要想在代码块外访问文件内容,可将文件的各行存款和储蓄在2个列表里,并在代码块外使用该列表

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)

 

3三、方法split()以空格为分隔符将字符串分拆为三个部分,并将那些有些都存款和储蓄到三个列表中

3四、模块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()

3伍、重构:将代码分为一各种成就具体做事的函数,使得代码更清晰、更易于精通、更便于扩大

3陆、测试代码

 

接待阅读,有任何不当能够提议,多谢

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图