澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

读书笔记,多少个java程序员的python之旅

2019-09-11 作者:www.8455.com   |   浏览(154)

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

Python 编制程序:从入门到实战 读书笔记,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    
                     缩进每一回用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()

读书笔记,多少个java程序员的python之旅。 

     按顺序获取再次来到成分可在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()

读书笔记,多少个java程序员的python之旅。    再次来到字典    

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','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

 

    (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_workPythonpi_digits.txt
    过长的门路影响雅观,所以能够将其放在七个变量里

file_path = 'D:code_workPythonpi_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_workPythonpi_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、测量检验代码

 

款待阅读,有任何不当能够提出,感谢

 

编制程序:从入门到实战 读书笔记,python读书笔记 1、.title() 种种单词首字母大写 .upper() 全部字母大写 .lower() 全部字母小写 2、 t 空白...

澳门新萄京官方网站 1

[TOC]

第八章(二)

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

连带阅读:跟上时期的步履,学一波Python(一)

笔录一下要好的python学习之旅,入门书籍为《python编制程序:从入门到实践》,运转条件为python3.6.3。也是有必然的编制程序基础,对于一些通用的语法不再赘述,本篇主要记录一下python一些不及于java的着力语法

3、返回值

函数重临的值被可以称作重回值。在函数中,可选取return语句将值重临到调用函数的代码行。重返值能够将先后中山大学部费劲的专门的学问移到函数中去完结,进而简化程序。

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

6. 字典

挥洒格式

  • 一句代码的截至以换行为标识,无需分号。
  • 建议每级缩进都施用多少个空格。
  • 建议每行不超过80字符,建议注释的行长不抢先72字符。
  • 不等的逻辑之间可用贰个空行隔绝。
  • 代码块不要求大括号,python依据缩进来判别代码行与前一个代码行的关联。
  • python变量和函数命名习贯使用小写,可用下划线隔开分离,不像java选拔驼峰命名法。
  • 在规范测量检验的格式设置方面,建议在诸如== 、>= 和<= 等相比较运算符两侧各增进三个空格。
(1)再次来到轻便值
def get_formatted_name(first_name, last_name):
    full_name = first_name   ' '   last_name
    return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
# 输出:
Jimi Hendrix

本条函数将接受到的姓名整洁地重新出口。

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

6.1 七个简易的字典

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color']) 
print(alien_0['points'])

字典alien_0 存款和储蓄了外星人的水彩和点数。使用两条print 语句来访谈并打字与印刷那个消息,如下所示:

green 
5

变量

变量不供给声明。

message = "Hello Python"
print(message)
(2)让实参变成可选的

让实参产生可选的,能够让动用函数的人独有在要求时才提供额外的新闻。可利用私下认可值来让实参形成可选的。

def get_formatted_name(first_name, last_name, middle_name=''):
    if middle_name:
        full_name = first_name   ' '   middle_name   ' '   last_name
    else:
        full_name = first_name   ' '   last_name
    return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
musician = get_formatted_name('john', 'hooker', 'lee')
print(musician)
# 输出:
Jimi Hendrix
John Lee Hooker

在上头的函数中增加了壹当中级名,若没有给定默许值,调用时只提供名和姓,Python会报错。而给它壹个空字符串作为暗中认可值就不会报错。给了暗许值的参数必得移到未有默许值的参数后边。在调用函数的时候,有暗许值的形参是不是传递实参,完全在于调用的人是还是不是须求。可选值让函数能够管理各类差别的情事的还要,确认保障函数调用尽或然不难。

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

6.2 使用字典

在Python中,字典 是一多级键—值对 。各个键 都与一个值相关联,你能够行使键来访谈与之相关联的值。与键相关联的值能够是数字、字符串、列表以致字典。事实上,可将其余Python对象用作字典中的值。
在Python中,字典用放在花括号{} 中的一类别键—值对代表,如前方的事必躬亲所示:

alien_0 = {'color': 'green', 'points': 5}

字符串

  • 字符串能够用双引号,也得以用单引号,那样能够一本万利的在字符串中利用引号,当然也足以像java一下由此转义字符表示引号。
  • python中的字符串也卷入了非常多的基本操作方法,举例大小写调换,去首尾空格等,能够在应用进度中国和日本渐去熟识。
message = " Hello world "
print(message.title())  # 首字母大写
print(message.lower())  # 转换小写
print(message.upper())  # 转换大写
print(message.count("o"))  # 字符计数
print(message.strip())  # 去首尾空格
print(message.lstrip())  # 去开头空格
print(message.rstrip())  # 去结尾空格
print(message.__len__())  # 字符串长度
(3)重回字典

函数可回到任何项目的值,满含列表和字典等比较复杂的的数据结构。

def build_person(first_name, last_name):
    person = {'first': first_name, 'last': last_name}
    return person
musician = build_person('jimi', 'hendrix')
print(musician)
# 输出:
{'first': 'jimi', 'last': 'hendrix'}

在那么些函数中,你可以轻易的扩展这么些函数,使其抽出可选值。

def build_person(first_name, last_name, age=''):
    person = {'first': first_name, 'last': last_name}
    if age:
        person['age'] = age
    return person
musician = build_person('jimi', 'hendrix', age=27)
print(musician)
# 输出:
{'first': 'jimi', 'last': 'hendrix', 'age': 27}

在那边新添了一个可选的形参age。同理也能够实行别的消息的恢宏。

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

6.2.1 访问字典中的值

要收获与键相关联的值,可依次钦定字典名和位于方括号内的键,如下所示:

alien_0 = {'color': 'green'} 
print(alien_0['color'])

那将赶回字典alien_0 中与键'color' 相关联的值:

green

数字

  • 数字和字符串不可能直接拼接。
print("Hello "   213)  # TypeError: must be str, not int
print("Hello "   str(213))  # Hello 213
(4)结合使用函数和while循环
def get_formatted_name(first_name, last_name):
    full_name = first_name   ' '   last_name
    return full_name.title()
while True:
    print("nPlease tell me your name:")
    print("(enter 'q' at any time to quit)")
    f_name = input("First name: ")
    if f_name == 'q':
        break
    l_name = input("Last name: ")
    if l_name == 'q':
        break
    formatted_name = get_formatted_name(f_name, l_name)
    print("nHello, "   formatted_name   "!")
# 输出:
Please tell me your name:
(enter 'q' at any time to quit)
First name: eric
Last name: matthes

Hello, Eric Matthes!

Please tell me your name:
(enter 'q' at any time to quit)
First name: q

     Python 用 来统一字符串  "wanyu" " " "shuai"

6.2.2 添加键—值对

字典是一种动态结构,可随时在里面加多键—值对。要增添键—值对,可依次钦点字典名、用方括号括起的键和相关联的值。

alien_0 = {'color': 'green', 'points': 5} 
print(alien_0)
alien_0['x_position'] = 0 
alien_0['y_position'] = 25
print(alien_0)

输出结果:

{'color': 'green', 'points': 5}
{'color': 'green', 'points': 5, 'y_position': 25, 'x_position': 0}

整数

  • python中能够用 ** 表示乘方运算
  • python3中四个整数相除时,会获得实在的结果,而python第22中学只会得到整数部分,那与java类似(3/2=1)。
print(2 ** 3)  # 8
print(3 / 2)  # 1.5
print(4 / 3)  # 1.3333333333333333

4、传递列表

将列表传递给函数后,函数就能够平素访谈其剧情。用函数访谈列表中的每种人:

def greet_users(names):
    for name in names:
        msg = "Hello, "   name.title()   "!"
        print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)
# 输出:
Hello, Hannah!
Hello, Ty!
Hello, Margot!

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

6.2.3 修改字典中的值

要修改字典中的值,可依次内定字典名、用方括号括起的键以及与该键相关联的新值。

alien_0 = {'color': 'green'}
print("The alien is "   alien_0['color']   ".")
alien_0['color'] = 'yellow'
print("The alien is now "   alien_0['color']   ".")

出口结果:

The alien is green.
The alien is now yellow.

注释

  • python中注释用#来表示。
(1)在函数中期维修改列表

将列表传递给函数后,函数就可对其张开更改。在函数中对那个列表所做的别的修改都以永世的。

def print_models(unprinted_designs, completed_models):
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print("Printing model: "   current_design)
        completed_models.append(current_design)

def show_completed_models(completed_models):
    print("nThe following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)

unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)
# 输出:
Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone case

The following models have been printed:
dodecahedron
robot pendant
iphone case

以那一件事例演示了一种思想,即每一个函数都应只担当一项具体的劳作。编写函数时,倘使你意识它施行的义务太多,能够品味将它分到多个函数中,而且连接能够在叁个函数中调用另一个函数,那有利于将复杂的职分划分成一名目多数的步调。

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

6.2.4 删除键—值对

对此字典中不再需求的音讯,可接纳del 语句将相应的键—值对根本删除。使用del 语句时,必需钦定字典名和要刨除的键。

alien_0 = {'color': 'green', 'points': 5} 
print(alien_0)
del alien_0['points'] 
print(alien_0)

出口结果:

{'color': 'green', 'points': 5} 
{'color': 'green'}

列表

稳步集中,用[]代表。类似于但又区别于java中的数组、群集。

  • python中的列表不供给数据类型同样,及不用类型的数量能够停放同三个列表中,姑且简单明了为List<Object>。
  • 以不改变应万变集中,因而帮忙按索引访谈,索引从0开头。分裂的是python还支持反向索引,-1意味着最终一个数量,-2意味尾数第1个,依次类推。
names = ["Allen", "Toto", 123]
print(names)  # ['Allen', 'Toto', 123]
print(names[1])  # Toto
print(names[-1])  # 123
  • 修改成分:类似于java数组,直接通过索引赋值修改。
  • 添先令素:提供append和insert方法,分别用于在列表末尾追加和在钦命索引地方插入新因素。
  • 删去成分:提供pop和remove方法,分别用于删除内定索引和钦赐值的因素。也可用del语句来删除。注意remove方法只是剔除贰个成分,如若列表中有八个一律成分,能够透过轮回删除。
names = ["Allen", "Toto", 123]
print(names)  # ['Allen', 'Toto', 123]
names[2] = 456
print(names)  # ['Allen', 'Toto', 456]
names.append(True)
print(names)  # ['Allen', 'Toto', 456, True]
names.insert(1, 123)
print(names)  # ['Allen', 123, 'Toto', 456, True]
del names[-1]
print(names)  # ['Allen', 123, 'Toto', 456]
test = names.pop(-1)
print(names)  # ['Allen', 123, 'Toto']
print(test)  # 456
names.remove("Allen")
print(names)  # [123, 'Toto']
  • 排序:注意唯有全部元素为同一档案的次序的列表能够排序。能够通过列表的sort方法也许sorted函数来扩充排序,个中sort会更换原列表,sorted不会变动原列表。也足以透过参数来调控顺序。
names = ["Allen", "Toto", "Lili"]
names.sort()
print(names)  # ['Allen', 'Lili', 'Toto']
names.sort(reverse=True)
print(names)  # ['Toto', 'Lili', 'Allen']
print(sorted(names))  # ['Allen', 'Lili', 'Toto']
print(names)  # ['Toto', 'Lili', 'Allen']
  • 遍历:通过for循环实行遍历,类似于java中的foreach语句,仅仅是写法区别。
names = ["Allen", "Toto", "Lili"]
for item in names:  # 注意最后有个冒号,代码块需要缩进
    print(item)
  • 数值列表:python使用range函数能够很有益于的成立贰个数值列表,结果符合编制程序中最布满的差一作为,例如range(1,6),实际变化的为1到5那三个数字。
nums = list(range(1, 6))  # 创建数值列表
print(nums)  # [1, 2, 3, 4, 5]
# range还支持步数
nums = list(range(1, 6, 2))  # [1, 3, 5]
print(nums)
  • 列表分析:将for循环和创办新因素的代码合併成一行,并自行叠合新成分。下边三种写法是等价的。
nums = list()
for item in range(1, 6):
    nums.append(item ** item)
print(nums)  # [1, 4, 27, 256, 3125]

# 列表解析的格式为[表达式   for循环]
nums = [item ** item for item in range(1, 6)]
print(nums)  # [1, 4, 27, 256, 3125]
  • 切开:即截取列表的片段左近成分。通过点名要截取的率先个和尾声三个索引来举行切开,并得到一个新的列表澳门新萄京官方网站,。依旧符合差一表现。
nums = list(range(1, 11))
# 实际上是从索引1到4
print(nums[1:5])  # [2, 3, 4, 5]
# 没有指定开始索引会默认从0开始  没指定结束索引会默认到列表最后一个元素结束
print(nums[:5])  # [1, 2, 3, 4, 5]
print(nums[5:])  # [6, 7, 8, 9, 10]
print(nums[:])  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 也支持负索引
print(nums[-3:])  # [8, 9, 10]
  • 列表的复制:列表的复制能够平素动用切成条的措施,不能平昔将变量赋值给另八个变量,那和java中的概念(list.addAll)是一样的。
# 这样相当于将变量nums和nums_2都关联到了同一个列表,不是复制
nums = [1, 2, 3]
nums_2 = nums
nums_2.append(4)
print(nums_2)  # [1, 2, 3, 4]
print(nums)  # [1, 2, 3, 4]

# 可以用切片来达到复制列表的目的
nums = [1, 2, 3]
nums_2 = nums[:]
nums_2.append(4)
print(nums_2)  # [1, 2, 3, 4]
print(nums)  # [1, 2, 3]
(2)禁止函数修改列表

当你实行修改列表后,还需求运用未修改此前的列表时,能够将传递给函数的列表改为列表的别本并不是原件,那样函数所做的任何改变都只影响别本,而丝毫不影响原件。
用切成片表示法[:]开创列表的别本。如:

print_models(unprinted_designs[:], completed_models)

虽说向函数字传送递列表的别本可保存原始列表的剧情,但唯有有足够的说辞必要传递别本,否则依旧应该将原始列表传递给函数,因为让函数使用现存列表可防止花时间和内部存款和储蓄器创建副本,进而提升效用,在拍卖大型列表时更是如此。

 

6.3 遍历字典

多个Python字典大概只含有多少个键—值对,也说不定包括数百万个键—值对。鉴于字典可能满含多量的数量,Python接济对字典遍历。字典可用以以各个办法存款和储蓄新闻,因而有各种遍历字典的点子:可遍历字典的全部键—值对、键或值。

元组

python将不得修改的值称为不可变的,而不可变的列表称为元组。

  • 元组使用圆括号标志,除了成分不可变之外,能够向操作列表同样遍历、操作元组。
# 元组:不可变的列表
nums = (1, 2, 3)
print(nums)  # (1, 2, 3)
print(nums[-2:])  # (2, 3)

5、传递任性数量的实参

Python允许函数从调用语句中收载大肆数量的实参。

def make_pizza(*toppings):
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')
# 输出:
('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

形参名*toppings中的星号让Python创立叁个名叫toppings的空元组,并将选取的全体值都封装在那么些元组中,即便只抽出三个值也是封装在元组中。上述例子的第一条出口正是那般,独有一个因素的元组用小括号括起来,并在要素的末尾增添一个逗号。

6、单行注释 #
     多行注释 """   """  恐怕  ''' '''

6.3.1 遍历全部的键—值对

user_0 = {
        'username': 'efermi', 
        'first': 'enrico',
        'last': 'fermi',
}
for key, value in user_0.items(): 
      print("nKey: "   key)
      print("Value: "   value)

输出结果:

Key: last 
Value: fermi
Key: first 
Value: enrico
Key: username 
Value: efermi

if语句

语法同大多数编制程序语言,仅仅是书写格式差异。

  • 规格决断:
    • 分别轻重缓急写,即使不想区分轻重缓急写判别是还是不是等于,可以先都转变来小写再决断。
    • 支持==、>、<、>=、<=、!=判断。
    • 八个评定模范得以采纳andor第一字,效果等于java中的&&和||。
    • 判断成分是或不是含有在有些列表中时,能够行使innot in关键字。
    • python在进展标准推断时,会将非空的字符串或列表以为True,反之为False。
a = "a"
b = "A"
if a == b:  # a.lower() == b.lower()
    print("a == b")
elif a.lower() == b.lower():
    print("a.lower() == b.lower()")
else:
    print(False)

nums = [1, 2, 3]
nums_2 = [3, 4, 5]
if (3 in nums) and (3 not in nums_2):  # False
    print(True)
else:
    print(False)

nums = []
a = "a"
if nums:  # a
    print("nums")
elif a:
    print("a")
else:
    print(False)
(1)结合使用地点实参和自由数量实参

万一要让函数接收不一样门类的实参,必须在函数定义中校选取任性数量实参的形参放在最终。Python先相配岗位实参和要害字实参,再将盈余的实参都访谈到八个形参中。

def make_pizza(size, *toppings):
    print("nMaking a "   str(size)  
            "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- "   topping)

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
# 输出:
Making a 16-inch pizza with the following toppings:
- pepperoni

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

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

6.3.2 遍历字典中全部键

在没有须求选用字典中的值时,方法keys() 很有用。下面来遍历字典favorite_languages ,并将各样被调查者的名字都打字与印刷出来:

favorite_languages = 
        { 'jen': 'python', 
          'sarah': 'c', 
          'edward': 'ruby', 
          'phil': 'python', }
for name in favorite_languages.keys(): 
       print(name.title())

输出结果:

Jen 
Sarah 
Phil 
Edward

字典

在Python中,字典是一文山会海键--值对 。每一种键都与三个值相关联,你可以应用键来访谈与之相关联的值。与键相关联的值能够是数字、字符串、列表以致字典。事实上,可将别的Python对象用作字典中的值。类似于java中的Map。

  • python中,字典用花括号来标志,每二个键值对里面以逗号分隔。
student = {"name": "Allen", "age": 15}
  • 能够由此字典的键来访问与之提到的值。
  • 字典是一种动态结构,可随时在其间增添、修改键值对,只需点名字典的键就可以。
  • 能够由此del语句删除字典中的键值对。
student = {"name": "Allen", "age": 15}
print(student["name"])  # Allen
student["name"] = "Lili"
print(student)  # {'name': 'Lili', 'age': 15}
student["address"] = "ChangSha"
print(student)  # {'name': 'Lili', 'age': 15, 'address': 'ChangSha'}
del student["address"]
print(student)  # {'name': 'Lili', 'age': 15}
  • 能够透过for循环遍历字典的全部键、全体值也许是持有的键值对。不过不保障遍历顺序和仓库储存顺序同样。
student = {'name': 'Lili', 'age': 15, 'address': 'ChangSha'}
for k, v in student.items():
    print(str(k)   ":"   str(v))

for k in student.keys():  # 遍历字典时会默认遍历key,因此等效于 for k in student:
    print(k)

for v in set(student.values()):  # 如果需要去重的话,可以使用集合set,类似于列表,但每个元素都是独一无二的
    print(v)
(2)使用任意数量的严重性字实参

亟需吸取大肆数量的实参,但先行不晓得传递给函数的会是何等的新闻。那时候可将函数编写成能够摄取自便数量的键-值对——调用语句提供了有一些就收取多少。

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

user_profile = build_profile('albert', 'einstein',
                             location='princeton',
                             field='physics')
print(user_profile)
# 输出:
{'first_name': 'albert', 'last_name': 'einstein', 
'location': 'princeton', 'field': 'physics'}

形参**user_info中的四个星号让Python成立二个名称为user_info的空字典,并将接受的具盛名称-值对都打包到那么些字典中。
编辑函数时,能够以各样法子混合使用地方实参、关键字实参和任意数量的实参。

      访谈成分   正数 [ ]里从0开始   print(bike[0])
                       倒数           -1          print(bike[-1])

6.3.3 按梯次遍历字典中的全数键

字典总是确定地记录键和值时期的涉及关系,但收获字典的因素时,获取顺序是不可预测的。那不是主题素材,因为平时你想要的只是收获与键相关联的准确的值。 要以特定的依次重返元素,一种方法是在for 循环中对回到的键实行排序。为此,可选择函数sorted() 来赢得按一定顺序排列的键列表的别本:

favorite_languages = 
        { 'jen': 'python', 
          'sarah': 'c', 
          'edward': 'ruby', 
          'phil': 'python', }
for name in sorted(favorite_languages.keys()): 
        print(name.title())

输出结果:

Edward
Jen
Phil
Sarah

while循环

主干语法同半数以上编制程序语言,仅书写格式分化。

nums = [1, 1, 1, 1, 2, 2, 1, 3]
while 1 in nums:
    nums.remove(1)
print(nums)  # [2, 2, 3]

6、将函数存储在模块中

函数的亮点之一是,使用它们可将代码块与主程序分离。通过给函数钦定描述性名称,可让主程序轻易了然得多。还是能够将函数存款和储蓄在被誉为模块的单独文件中,再将模块导入到主程序中。import语句允许在脚下运作的顺序文件中央银行使模块中的代码。
由此将函数存款和储蓄在单独的公文中,可遮掩程序代码的细节,将首要放在程序的高层逻辑上。那足以在相当多不一的次序中收音和录音函数。将函数存款和储蓄在独立文件中后,可与其他技士分享那些文件并不是漫天程序。

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

6.3.4 遍历字典中的全体值

favorite_languages = 
        { 'jen': 'python', 
          'sarah': 'c', 
          'edward': 'ruby', 
          'phil': 'python', }
print("The following languages have been mentioned:") 
for language in favorite_languages.values():
    print(language.title())

这条for 语句提取字典中的每一个值,并将它们依次存款和储蓄到变量language 中。通过打字与印刷这个值,就获取了贰个列表,在这之中包涵被考察者采取的各类语言:

The following languages have been mentioned: 
Python
C
Python
Ruby

函数

  • 函数用关键词def定义,函数体依旧接纳缩进格局。
  • 函数的辨证文书档案用三引号注释,写在函数体的首先行。
def print_hello():
    """打招呼"""
    print("Hello")


print_hello()  # Hello
  • 参数字传送递:python中实参的传递有三种艺术:地点实参,关键字实参和暗许值。职位实参即基于实参的逐一依次传递,那是多数编制程序语言中的一种普及做法。要害字实参通过键值对的法门传送参数,不用思量参数的各种。默认值即在编写函数时为形参钦定二个暗中同意值,调用函数时一旦不点名实参,则选取此私下认可值。注意如若不钦定暗中同意值,则调用函数时必需传入该实参。
def print_hello(name, age="15"):
    """打招呼"""
    print("你好,我叫"   str(name)   ","   str(age)   "岁")


print_hello("李狗蛋", "12")  # 你好,我叫李狗蛋,12岁
print_hello("12", "李狗蛋")  # 你好,我叫12,李狗蛋岁
print_hello(age="12", name="李狗蛋")  # 你好,我叫李狗蛋,12岁
# 形参可以有默认值,相当于简化了java中的方法的多态
print_hello("李狗蛋")  # 你好,我叫李狗蛋,15岁
  • 重临值:python中等学校函授数能够通过重要字return重回二个值,且python是弱类型语言,无需钦点再次来到的值的品种。
  • 列表作为实参传入时,假诺函数内部对该列表做了改换,则原列表也会变动,这点同java是一律的。倘诺不想修改原列表,能够将列表的叁个别本作为实参传入,譬如利用切成条。
def getList(list):
    list[0] = 2
    return list


a = [1, 2]
print(getList(a))  # [2, 2]
print(a)  # [2, 2]
a = [1, 2]
print(getList(a[:]))  # [2, 2]
print(a)  # [1, 2]
  • 函数能够行使 * 形参名 的款型充足放肆数量的参数,类似于java中的 形参名 ... 符号,就算有四个例外类其他形参,这种接受任性数量参数的形参只好放在最终。
def muti(*name):  # 形参名*name 中的星号让Python创建一个名为name 的空元组,并将收到的所有值都封装到这个元组中。
    print(name)


muti("a")  # ('a',)
muti("a", "b", "c")  # ('a', 'b', 'c')
  • 函数能够由此七个星号来收取大肆数量的重要字实参(键值对)。
def person(name, age, **other):  # 形参名**other 中的星号让Python创建一个名为other 的空字典,并将收到的所有键值对都封装到这个字典中。
    p = {"name": name, "age": age}
    for k, v in other.items():
        p[k] = v
    print(other)


person("Allen", 15, sex="man", address="ChangSha")  # {'name': 'Allen', 'age': 15, 'sex': 'man', 'address': 'ChangSha'}
  • 导入外界函数:要让函数是可导入的,得先创制模块。模块是扩充名字为.py的公文,富含要导入到程序中的代码。导入方式:
    • import module_name:导入整个模块。
    • import module_name as other_name:为导入的模块起贰个小名。
    • from module_name import function_name:导入模块中的有个别函数,function_name能够有八个,用逗号隔断,表示导入该模块的三个函数。
    • from module_name import function_name as other_name:导入模块中的某些函数,并起三个小名,一般原函数名字太长只怕有同名函数时选择。
    • from module_name import *:导入该模块的全部函数。
      注:只导入模块时,需通过module_name.function_name调用(前两种格局),导入函数时,能够直接通过函数名使用(后三种办法)。当然,有外号的状态下也能够利用外号。
(1)导入整个模块

要让函数是可导入的,得先成立模块。模块是扩展名叫.py的文书,包罗要导入到程序中的代码。
将前面make_pizza函数放在二个名字为pizza.py的文书中,然后更创造贰个名称为making_pizzas.py的文书,在文件的上马加多import pizza,然后在上面写入调用函数的说话运维就可以。程序运转时,import会将pizza文件中的全数函数复制到程序中。
要调用被导入的模块中的函数,可内定导入的模块的称呼pizza和函数名make_pizza(),并用句点分隔它们。如:

pizza.make_pizza(16, 'pepperoni')

只需编写一条import语句并在其中钦赐模块名,就能够在程序中使用该模块中的全数函数。

module_name.function_name()

      添港成分   .append()         在末尾添美成分(可创立空列表然后用一种类.append()语句来增进)      bike.append('bcd')
                       .insert( , )         插入成分,需点名新成分的目录与值    bike.insert(0,'cde')

7. 函数

  • 由此珍视字class标志,类名的首字母大写,接纳驼峰命名法,能够在类名的下一行增多注释文书档案,用三引号标记。
  • python的类有一个奇特的点子__ init__(),每趟成立类的实例时都会运作这么些法子,类似于java中的构造函数。在这一个办法的名号中,开端和最后各有七个下划线,那是一种约定,目的在于制止Python暗许方法与常常方法发生名称争持。
  • 形参self不可或缺,还必得放在别的形参的日前。每种与类相关联的措施调用都活动传递实参self ,它是多个针对性实例本人的引用,让实例可以访谈类中的属性和办法。
  • 以self 为前缀的变量都可供类中的全数办法应用,我们仍可以够透过类的另外实例来访谈这几个变量,大家得以将这一个以self为前缀的变量称为属性。
class Person:
    """测试类"""
    def __init__(self, name="Allen", age=15, sex="man"):
        self.name = name
        self.age = age
        self.sex = sex
        self.address = ""
        print("person "   name   " init")

    def walk(self):
        print(self.name   " can walk.")

    def run(self):
        self.walk()
        print(self.name   " can run too.")
  • 继承。
class Person:
    """测试类"""

    def __init__(self, name, age=15, sex="man"):
        self.name = name
        self.age = age
        self.sex = sex
        self.address = ""
        print("person "   name   " init")

    def walk(self):
        print(self.name   " can walk.")

    def run(self):
        self.walk()
        print(self.name   " can run too.")


person = Person("Allen")  # person Allen init
person.run()  # Allen can walk.  Allen can run too.


class Student(Person):  # Student继承于Person
    def __init__(self, name):  # 子类的__init__方法需要接收父类的所有参数,有默认值的可以不传,会取默认值
        super().__init__(name)  # 子类继承父类的所有属性和方法

    def walk(self):  # 重写父类方法
        print("override function.")

    def get_teacher(self, teacher_name):  # 子类的自定义方法
        print(self.name   "'s teacher is "   teacher_name)


student = Student("Allen")  # person Allen init
student.get_teacher("Lili")  # Allen's teacher is Lili
student.walk()  # override function.
(2)导入特定的函数

导入模块中的特定函数:

from module_name import function_name

由此用逗号分隔函数名,可依据须求从模块中程导弹入大肆数量的函数:

from module_name import function_0, function_1, function_2

应用这种措施导入函数后,调用函数时就无需动用句点。因为已经在import语句中显示地导入了函数,所以调用时内定其名称就能够。

      删除成分   del 列表名[]          删除已知地方的列表成分     del bike[0]
                       列表名.pop()         删除索引地方而且能够再度被调用  即弹出功用   bike.pop(2)
                                del和pop()使用后,列表里对应成分均被删除,然而pop()能够三番伍回调用  依照删除后是或不是还需选用要素采取del和pop
                       列表名.remove()   删除已知成分值             bike.remove('abc')

7.1 定义函数

贰个归纳的函数

def greet_user():
"""显示简单的问候语""" 
print("Hello!")
greet_user()

输出结果:

Hello!

文本读写

通过open函数张开贰个文件,举办读写操作,达成后通过close函数关闭文件,也得以动用with关键字,让python本人接纳及时关闭文件。

def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True):

open函数可以选用八个mode参数,包含以下值:

  • 'r' 只读格局张开 (default)
  • 'w' 只写格局打开,展开文件会清空文件,再写入,文件不设临时会自动创建文件。
  • 'x' 创设二个新文件并以只写情势张开
  • 'a' 只写格局张开,张开文件会将写入内容拼接到文件最后,
  • 'b' 字节情势
  • 't' 文本方式(default)
  • ' ' 展开一个硬盘文件进行立异 (reading and writing)
  • 'U' universal newline mode (已过时)

暗许形式为"rt"。

(3)使用as给函数钦定外号

即使要导入的函数的名称或许与程序中存活的名称争辨,或然函数的名目太长,可内定简短而独步的小名——类似于给函数起三个绰号。若要这么做,就要在导入它时就要做。
在import语句中选拔首要字as将函数重命名字为您想要的别名:

from pizza import make_pizza as mp

因为有了三个小名,所以调用函数时方可一直用别称来调用。

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

7.1.1 向函数字传送递消息

只需稍作修改,就足以让函数greet_user() 不仅仅向顾客体现Hello! ,还将顾客的名字用作抬头。为此,可在函数定义def greet_user() 的括号内增多username 。通 过在此地增添username ,就可让函数接受你给username 钦命的另外值。未来,那一个函数要求您调用它时给username 钦点二个值。调用greet_user() 时,可将一个名字 传递给它,如下所示:

def greet_user(username):
"""显示简单的问候语"""
print("Hello, "   username.title()   "!")
greet_user('jesse')

代码greet_user('jesse') 调用函数greet_user() ,并向它提供实行print 语句所需的新闻。这些函数接受你传递给它的名字,并向这厮发出问候:

Hello, Jesse!

读文件

测验文件 file_io_test:

abcdefg
hijklmn
opq
rst
uvw
xyz
  • 读取整个文件
with open("file_io_test") as file:  # 关键字with 在不再需要访问文件后适时将其关闭。
    print(file.read())  # read()可以接收一个int参数,表示读取的字节数,传-1表示读取全部,默认值为-1
  • 读取一行
with open("file_io_test") as file:
    print(file.readline())  # abcdefg 行末尾有一个换行符
    print(file.readline())  # hijklmn
  • 读取每行,并蕴藏到两个列表
with open("file_io_test") as file:
    print(file.readlines())  # ['abcdefgn', 'hijklmnn', 'opqn', 'rstn', 'uvwn', 'xyz']
  • 逐行读取
with open("file_io_test") as file:
    for line in file:  # 等同于line = file.readline()
        print(line)
  • 是不是可读
with open("file_io_test") as file:
    print(file.readable())  # readable()是否可读,返回一个布尔值
(4)使用as给模块钦赐小名

给模块钦命别名,能使代码更简明,並且不再关切模块名,而潜心于描述性的函数名,对领悟代码更加好。

import module_name as mn

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

7.1.2 实参和形参

前边定义函数greet_user() 时,需要给变量username 钦赐七个值。调用那些函数并提供这种新闻(人名)时,它将打字与印刷相应的问候语。
在函数greet_user() 的定义中,变量username 是一个形参 ——函数实现其行事所需的一项音讯。在代码greet_user('jesse') 中,值'jesse' 是二个实参 。实参是 调用函数时传递给函数的消息。我们调用函数时,将在让函数使用的新闻放在括号内。在greet_user('jesse') 中,将实参'jesse' 传递给了函数greet_user() ,这么些值被储存在形参username 中。

写文件

with open("file_write_test", mode="w ") as file:  # w换成a后可以附加到文件中,不会覆盖
    file.write("456")  # 写入456
    print(file.readable())  # True
(5)代入模块中的全部函数

采用星号(*)运算符可让Python导入模块中的全体函数。由于导入了各种函数,可透过名称来调用每一种函数,而不必要选择句点表示法。不过,使用并不是本身编写的大型模块时,最好不要采纳这种导入方法:如若模块中有函数的名称与你的体系中接纳的名目一致,恐怕引致意外的结果:Python只怕遇见七个称呼一致的函数或变量,进而覆盖函数,并不是各自导入全部函数。
最好的做法是,要么只导入你供给动用的函数,要么导入整个模块并行使句点表示法。

from module_name import *

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

7.2 传递实参

鉴于函数定义中大概富含八个形参,由此函数调用中也恐怕带有多少个实参。向函数字传送递实参的方法相当多,可应用地点实参 ,那要求实参的顺序与形参的顺序一样;也可采取首要字实参 ,在那之中每种实参都由变量名和值组成;还可采用列表和字典。下边来每家每户介绍那个格局。

异常

管理特别:

def divide(a, b):
    """除法运算"""
    try:
        result = a / b
    except ZeroDivisionError:
        print("除数不能为0")
    else:
        print(result)
    finally:
        print("运行完毕")


divide(1, 0)  # 除数不能为0  运行完毕
divide(1, 5)  # 0.2  运行完毕

7、函数编写指南

应给函数内定描述性名称,且只在中间使用小写字母和下划线。给模块命名时也应依照上述约定。
各种函数都应富含简要地演讲其职能的笺注,该注释紧跟在函数定义前面,并运用文书档案字符串格式。
给形参钦命暗许值时,等号两侧不要有空格。对于函数调用中的关键字实参,也应遵从这种约定。
倘使函数的形参相当多,导致函数定义的长短超过了79字符,可在函数定义中输入左括号后按回车键,并在下一行按两遍Tab键,进而将形参列表和只缩进一层的函数体区分开来。
固然程序或模块包蕴五个函数,可选拔四个空行将相近的函数分开,那样将更易于驾驭前一个函数在怎么样地方截止,下一个函数在怎么地点开首。
怀有的import语句都应放在文件开始,独一差别的图景是,在文书开头使用了解说来说述整个程序。

10、for 变量 in 列表:   for循环,且for循环后的每一句代码,未有缩进的只实行一回,缩进的双重实行   注意‘:’和缩进        

7.2.1 地点实参

参数字传送递时,须求依照形参的职位顺序来传递,如下例所示,animal的type和name需按梯次传入

 def describe_pet(animal_type, pet_name): 
        """显示宠物的信息"""
        print("nI have a "   animal_type   ".")
        print("My "   animal_type   "'s name is "   pet_name.title()   ".")
describe_pet('hamster', 'harry')

出口结果:

I have a harry.
My harry's name is Hamster.

积累数据

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

7.2.2 关键字实参

一言九鼎字实参 是传递给函数的称呼—值对。你直接在实参大校名称和值关联起来了,由此向函数字传送递实参时不会搅乱(不会获得名叫Hamster的harry那样的结果)。关键字实参让你无需思考函数调用中的实参顺序,还知道地建议了函数调用中相继值的用途。

def describe_pet(animal_type, pet_name):
      """显示宠物的信息"""
      print("nI have a "   animal_type   ".")
      print("My "   animal_type   "'s name is "   pet_name.title()   ".")
describe_pet(animal_type='hamster', pet_name='harry')

输出结果:

I have a harry.
My harry's name is Hamster.

通过json存储

import json

nums = [1, 2, 3, 4, 5]
with open("jsonTest.json", "w") as file:
    json.dump(nums, file)  # 写入文件,接收一个内容对象和文件对象

with open("jsonTest.json") as file:
    result = json.load(file)
    print(result)

 

7.2.3 默认值

编排函数时,可给各样形参钦赐默许值 。在调用函数中给形参提供了实参时,Python将采取钦命的实参值;否则,将运用形参的暗许值。由此,给形参钦赐暗许值后,可在函数调用中归纳相应的实参。使用暗中认可值可简化函数调用,还可驾驭地提议函数的优秀用法。

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() 的概念,在里面给形参animal_type 钦命了默许值'dog' 。那样,调用那么些函数时,若无给animal_type 内定值,Python将把这些 形参设置为'dog' :

I have a dog.
My dog's name is Willie.

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

7.3 返回值

函数并非总是直接呈现输出,相反,它能够管理局地数据,并回到一个或一组值。函数再次回到的值被称作重临值 。在函数中,可利用return 语句将值重临到调用函数的代码行。

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

7.3.1 再次回到简单值

上面来看几个函数,它承受名和姓并赶回整洁的真名:

def get_formatted_name(first_name, last_name): 
      """返回整洁的姓名"""
      full_name = first_name   ' '   last_name
      return full_name.title()
musician = get_formatted_name('jimi', 'hendrix') print(musician)

出口结果:

Jimi Hendrix

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

7.3.2 重临字典

函数可回到任何项指标值,包含列表和字典等较复杂的数据结构。比如,上边包车型地铁函数接受姓名的组成都部队分,并重返三个意味着人的字典:

def build_person(first_name, last_name): 
      """返回一个字典,其中包含有关一个人的信息"""
      person = {'first': first_name, 'last': last_name} 
      return person
musician = build_person('jimi', 'hendrix') 
      print(musician)

输出结果:

{'first': 'jimi', 'last': 'hendrix'}

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

7.3.3 结合使用函数和while循环

可将函数同本书后边介绍的别的Python结构重组起来使用。比如,下边将构成使用函数get_formatted_name() 和while 循环,以更标准的格局问候客户。上边尝试利用名

def get_formatted_name(first_name, last_name): 
      """返回整洁的姓名"""
      full_name = first_name   ' '   last_name return full_name.title()
while True:
      print("nPlease tell me your name:") 
      print("(enter 'q' at any time to quit)")
      f_name = input("First name: ") 
      if f_name == 'q':
      break
l_name = input("Last name: ") 
      if l_name == 'q':
      break
formatted_name = get_formatted_name(f_name, l_name) 
      print("nHello, "   formatted_name   "!")

作者们增加了一条新闻来报告客户怎样退出,然后在每回提醒顾客输入时,都检查他输入的是还是不是是退出值,要是是,就退出循环。以后,这些程序将持续地问候,直到客商输入的姓或名称为'q' 停止:

Please tell me your name: 
(enter 'q' at any time to quit) 
First name: eric
Last name: matthes
Hello, Eric Matthes!
Please tell me your name: 
(enter 'q' at any time to quit) 
First name: q

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

7.4 传递列表

def greet_users(names): 
      """向列表中的每位用户都发出简单的问候""" 
      for name in names:
            msg = "Hello, "   name.title()   "!" 
            print(msg)
usernames = ['hannah', 'ty', 'margot'] 
greet_users(usernames)

输出结果:

Hello, Hannah! 
Hello, Ty! 
Hello, Margot!

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

7.5 将函数存在模块中

函数的长处之一是,使用它们可将代码块与主程序分离。通过给函数内定描述性名称,可让主程序轻易驾驭得多。你还足以更进一步,将函数存储在被称之为模块 的独自文件中,再将模块导入 到主程序中。import 语句允许在当前运维的程序文件中选取模块中的代码。 通过将函数存款和储蓄在独立的文件中,可隐敝程序代码的细节,将重大放在程序的高层逻辑上。那还能够让你在众多不等的次序中选拔函数。将函数存款和储蓄在独立文件中后,可与其他技士分享这么些文件并非整套程序。知道如何导入函数还是可以够让您利用别的技士编写的函数库。

15、切片:列表名[x:y]   列表里第x 1到第y个要素
          x未写则意味着从头早先,y未写则意味着到尾截止
          x、y都未写则可用来列表的复制       friends_foods=my_foods[:]     假设只是轻松的把多个列表赋给三个变量,就不能够博得三个列表
          x若为负数,则为回去列表的后x位

7.5.1 导入整个模块

要让函数是可导入的,得先创制模块。模块 是扩展名字为.py的文书,包涵要导入到程序中的代码。下边来创设三个包涵函数make_pizza() 的模块。为此,大家将文件pizza.py中除函数make_pizza() 之外的其他代码都剔除:
pizza.py

def make_pizza(size, *toppings): 
      """概述要制作的比萨""" 
      print("nMaking a "   str(size)  "-inch pizza with the following toppings:") 
      for topping in toppings:
            print("- "   topping)

接下去,大家在pizza.py所在的目录中开创另贰个名称叫making_pizzas.py的公文,这些文件导入刚创设的模块,再调用make_pizza() 两次:
making_pizzas.py

import pizza
pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Python读取这几个文件时,代码行import pizza 让Python打开文件pizza.py,并将里面包车型地铁装有函数都复制到那些顺序中。你看不到复制的代码,因为这些程序运转时,Python在幕 后复制这几个代码。你只需清楚,在making_pizzas.py中,能够使用pizza.py中定义的富有函数。

Making a 16-inch pizza with the following toppings: 
- pepperoni
Making a 12-inch pizza with the following toppings: 
- mushrooms
- green peppers
- extra cheese

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

7.6.2 导入特定的函数

您还足以导入模块中的特定函数,这种导入方法的语法如下:

from module_name import function_name

经过用逗号分隔函数名,可依靠必要从模块中程导弹入任性数量的函数:

from module_name import function_0, function_1, function_2

16、()表示元组    即不可变的列表,逗号隔断成分,访问成分与列表一样
                  遍历元组则用for循环        for bike in bikes:
                  元组的因素不可以被修改,不过全体元组能够被再一次赋值       bikes=(200,100)   bikes=(50,100)

7.6.3 使用as给函数钦赐外号

一旦要导入的函数的称号也许与程序中现成的称呼争持,或然函数的称呼太长,可钦命简短而独步天下的小名——函数的另三个称号,类似于外号。要给函数钦赐这种独特别名,须要在导入它时如此做。
上面给函数make_pizza() 内定了别称mp() 。这是在import 语句中动用make_pizza as mp 达成的,关键字as 将函数重命名称叫您提供的外号:

from pizza import make_pizza as mp
mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

下边包车型地铁import 语句将函数make_pizza() 重命名称叫mp() ;在这几个顺序中,每当要求调用make_pizza() 时,都可简写成mp() ,而Python将运维make_pizza() 中的代 码,那可幸免与那么些顺序大概带有的函数make_pizza() 混淆。

钦命小名的通用语法如下:

from module_name import function_name as fn

17、代码格式PEP8    
                     缩进每一次用4个空格
                     利用空行让代码看上去整洁
                     ==、>=、<= 两侧各增加一个空格
                     满含五个函数时,提议各样函数之间空2行

7.6.4 使用as给模块钦赐小名

您还能够给模块钦定外号。通过给模块钦命简短的外号(如给模块pizza 钦命别名p ),令你能够更轻巧地调用模块中的函数。比较于pizza.make_pizza(),p.make_pizza() 更为简单:

import pizza as p
p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

给模块钦点别称的通用语法如下:

import module_name as mn

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

7.6.5 导入模块中的全体函数

选用星号(* )运算符可让Python导入模块中的全数函数:

from pizza import *
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

        注意(1)冒号:不能丢
               (2)if、else前边的讲话换行写时要缩进
               (3)elif能够有多句,else可以未有
               (4)当供给推行多个代码块,也得以用五个if语句

8. 类

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

8.1 创造和使用类

采用类大概能够依样葫芦任何事物。上面来编排三个象征家狗的简短类Dog ——它象征的不是一定的黑狗,而是其它小狗。对于大好些个宠物狗,大家都通晓些什么啊?它们皆知名字 和年龄;大家还清楚,大许多黄狗还可能会蹲下和打滚。由于大多数黄狗都享有上述两项新闻(名字和年龄)和三种行为(蹲下和打滚),大家的Dog 类将蕴含它们。这些类让 Python知道怎么着创造表示黄狗的对象。编写这些类后,大家将选择它来创制表示一定黄狗的实例。

         第贰个mushrooms检查实验通过了,程序将跳过下边包车型大巴elif结构,不再检查其余内容,所以if-elif-else结构仅适用于唯有一个尺码满意的情状

8.1.1 创建Dog类

class Dog(): 
      """一次模拟小狗的简单尝试"""
      def __init__(self, name, age): 
            """初始化属性name和age"""
            self.name = name self.age = age
      def sit(self): 
            """模拟小狗被命令时蹲下""" 
            print(self.name.title()   " is now sitting.")
      def roll_over(self): 
            """模拟小狗被命令时打滚""" 
            print(self.name.title()   " rolled over!")

         而想要检验几个原则知足的事态应该用四个if语句

8.1.2 依照类创立实例

class Dog(): 
      --snip--
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's name is Willie. 
My dog is 6 years old.

调用方法

class Dog(): 
      --snip--
my_dog = Dog('willie', 6) 
my_dog.sit() 
my_dog.roll_over()

出口结果:

Willie is now sitting. 
Willie rolled over!

始建多少个实例

class Dog(): 
      --snip--
my_dog = Dog('willie', 6) 
your_dog = Dog('lucy', 3)
print("My dog's name is "   my_dog.name.title()   ".") 
print("My dog is "   str(my_dog.age)   " years old.") my_dog.sit()
print("nYour dog's name is "   your_dog.name.title()   ".") 
print("Your dog is "   str(your_dog.age)   " years old.") your_dog.sit()

出口结果:

My dog's name is Willie. 
My dog is 6 years old. 
Willie is now sitting.
Your dog's name is Lucy. 
Your dog is 3 years old. 
Lucy is now sitting.
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()

8.2 使用类和实例

  

8.2.1 Car类

class Car(): 
      """一次模拟汽车的简单尝试"""
      def __init__(self, make, model, year): """初始化描述汽车的属性"""
            self.make = make
            self.model = model
            self.year = year
      def get_descriptive_name(self):
            """返回整洁的描述性信息"""
            long_name = str(self.year)   ' '   self.make   ' '   self.model 
            return long_name.title()
my_new_car = Car('audi', 'a4', 2016) 
print(my_new_car.get_descriptive_name())

输出结果:

2016 Audi A4

19、=  赋值
       == 等于   检查字符是或不是等于时,会有别于轻重缓急写,若要不区分的话,可使用.lower()
       != 不等于
       and 与
       or  或
       in  满含在列表中
       not in  未富含在列表中

8.2.2 给属性暗中同意值

类中的各样属性都无法不有开端值,哪怕这么些值是0或空字符串。在有个别景况下,如设置暗中同意值时,在措施init() 内钦点这种初叶值是一蹴而就的;如若您对有些属性那样做 了,就不必要包涵为它提供早先值的形参。
下边来增添贰个名字为odometer_reading 的属性,其开端值总是为0。大家还增多了贰个名叫read_odometer() 的方式,用于读取小车的里程表:

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): 
            --snip--
      def read_odometer(self):
            """打印一条指出汽车里程的消息"""
            print("This car has "   str(self.odometer_reading)   " miles on it.")
my_new_car = Car('audi', 'a4', 2016) 
print(my_new_car.get_descriptive_name()) 
my_new_car.read_odometer()

输出结果:

2016 Audi A4
This car has 0 miles on it.
>>>bikes=['a','b','c']
>>>'a' in bikes
>>>True

8.2.3 修改属性的值

1.直接修改属性的值

class Car(): 
      --snip--
      my_new_car = Car('audi', 'a4', 2016) 
      print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23 
my_new_car.read_odometer()

输出结果:

2016 Audi A4
This car has 23 miles on it.

2.因此措施修改属性的值

class Car(): 
      --snip--
      def update_odometer(self, mileage): 
            """将里程表读数设置为指定的值""" 
            self.odometer_reading = mileage
my_new_car = Car('audi', 'a4', 2016) 
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23) 
my_new_car.read_odometer()

出口结果:

2016 Audi A4
This car has 23 miles on it.

3.由此措施对质量的值实行递增
突发性需求将属性值递增特定的量,实际不是将其安装为全新的值。若是大家购买了一辆二手车,且从购销到登记时期增添了100英里的路程,上面包车型大巴方法让大家能够传递这些增量,并相应地充实里程表读数:

class Car(): 
      --snip--
      def update_odometer(self, mileage): 
      --snip--
      def increment_odometer(self, miles): 
            """将里程表读数增加指定的量""" 
            self.odometer_reading  = miles
my_used_car = Car('subaru', 'outback', 2013) 
print(my_used_car.get_descriptive_name())
my_used_car.update_odometer(23500) 
my_used_car.read_odometer()
my_used_car.increment_odometer(100) 
my_used_car.read_odometer()

出口结果:

2013 Subaru Outback
This car has 23500 miles on it. 
This car has 23600 miles on it.

      if 列表名:    如若列表不为空,则会回来True;假若列表为空,重回值为False

8.3 继承

编写制定类时,并不是总是要从室如悬磬开始。假如你要编写的类是另一个现存类的新鲜版本,可应用承接。贰个类承继另两个类时,它将机关获得另二个类的具备属性和措施;原有的类称为父类 ,而新类称为子类 。子类继承了其父类的享有属性和艺术,同期还足以定义本身的性质和方法。

 

8.3.1 子类的办法init()

创制子类的实例时,Python首先需求形成的天职是给父类的保有属性赋值。为此,子类的措施init() 需求父类施以助手。
electric_car.py

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):
            long_name = str(self.year)   ' '   self.make   ' '   self.model
            return long_name.title()
      def read_odometer(self):
            print("This car has "   str(self.odometer_reading)   " miles on it.")
      def update_odometer(self, mileage):
            if mileage >= self.odometer_reading:
                  self.odometer_reading = mileage 
            else:
                  print("You can't roll back an odometer!")
      def increment_odometer(self, miles): 
            self.odometer_reading  = miles
class ElectricCar(Car): 
      """电动汽车的独特之处"""
      def __init__(self, make, model, year): 
            """初始化父类的属性"""
            super().__init__(make, model, year)
my_tesla = ElectricCar('tesla', 'model s', 2016) 
print(my_tesla.get_descriptive_name())

输出结果:

2016 Tesla Model S

20、布尔表明式  True / False

8.3.2 Python2.7中的承继

在Python 2.7中,承袭语法稍有两样,ElectricCar 类的概念类似于上面那样:

class Car(object):
      def __init__(self, make, model, year):
            --snip--
class ElectricCar(Car):
      def __init__(self, make, model, year):
            super(ElectricCar, self).__init__(make, model, year) 
            --snip--

 

8.3.3 给子类定义属性和艺术

让二个类承继另二个类后,可增加区分子类和父类所需的新属性和措施。 上面来增多一个电动汽车特有的品质(电池),以及二个描述该属性的章程。我们将积累电池体量,并编辑二个打字与印刷电池描述的艺术:

class Car(): 
      --snip--
class ElectricCar(Car):
      """Represent aspects of a car, specific to electric vehicles."""
      def__init__(self, make, model, year): 
            """电动汽车的独特之处 初始化父类的属性,再初始化电动汽车特有的属性 """
            super().__init__(make, model, year) 
            self.battery_size = 70
      def describe_battery(self):
            """打印一条描述电瓶容量的消息"""
            print("This car has a "   str(self.battery_size)   "-kWh battery.")
my_tesla = ElectricCar('tesla', 'model s', 2016) 
print(my_tesla.get_descriptive_name()) 
my_tesla.describe_battery()

出口结果:

2016 Tesla Model S
This car has a 70-kWh battery.

21、字典是放在{}里的一连串键值对,键必要加''而值不料定  键值之间用:隔开分离  键值对里面用,隔开分离
        字典名={'键':值}    alien_0={'color':'gerrn','points':5}

8.3.4 重写父类的艺术

对于父类的法子,只要它不相符子类模拟的玩意的一言一动,都可对其开展重写。为此,可在子类中定义叁个这么的主意,即它与要重写的父类方法同名。这样,Python将不会虚构这些父类方法,而只关切您在子类中定义的对应措施。

def ElectricCar(Car): 
      --snip--
def fill_gas_tank():
      """电动汽车没有油箱"""
      print("This car doesn't need a gas tank!")

        访谈字典值  可依次钦定字典名和位于[]的键   即  字典名['键']     print(alien_0['color'])

8.3.5 将实例用作属性

使用代码模拟实物时,你可能会发掘自个儿给类增长的内部原因更增添:属性和艺术清单以及文件都越来越长。在这种状态下,大概供给将类的一有个别作为三个独立的类提抽取来。你可以将重型类拆分成三个协同专门的学问的小类。
举个例子,不断给ElectricCar 类增多细节时,大家也许会意识其间包涵众多特地针对汽车电池的习性和措施。在这种气象下,大家可将这个属性和情势提收取来,放到另多少个名称叫Battery 的类中,并将三个Battery 实例用作ElectricCar 类的壹特性质:

class Car(): 
      --snip--
class Battery(): 
      """一次模拟电动汽车电瓶的简单尝试"""
      def __init__(self, battery_size=70): 
            """初始化电瓶的属性""" 
            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, make, model, year): 
            """ 初始化父类的属性,再初始化电动汽车特有的属性 """
            super().__init__(make, model, year) 
            self.battery = Battery()
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name()) 
my_tesla.battery.describe_battery()

出口结果:

my_tesla.battery.describe_battery()
2016 Tesla Model S
This car has a 70-kWh battery

        加多键值对  依次钦命字典名、[]括起来的键和关系的值   即  字典名['键']=值
                Python不保养键值对的逐个,只关切键和值的呼应关系
                alien_0['x_position']=0
                alien_0['y_position']=25
                相当多时候是先创立一个空字典,再各自增多键值对       字典名={}

8.4 导入类

乘机你不停地给类增添效果,文件大概变得不长,即让你妥善地使用了接二连三亦如此。为遵照Python的完全思想,应让文件尽大概整洁。为在那上头提供接济,Python允许你将类存储在模块中,然后在主程序中程导弹入所需的模块。

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

8.4.1 导入单个类

car.py

"""一个可用于表示汽车的类""" 
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):
            """返回整洁的描述性名称"""
            long_name = str(self.year)   ' '   self.make   ' '   self.model return long_name.title()
     def read_odometer(self):
            """打印一条消息,指出汽车的里程"""
            print("This car has "   str(self.odometer_reading)   " miles on it.")
    def update_odometer(self, mileage): 
            """
            将里程表读数设置为指定的值
            拒绝将里程表往回拨
            """
            if mileage >= self.odometer_reading:
                  self.odometer_reading = mileage 
            else:
                  print("You can't roll back an odometer!")
      def increment_odometer(self, miles):
             """将里程表读数增加指定的量""" 
             self.odometer_reading  = miles

上面来制造另二个文件——my_car.py,在里头导入Car 类并创立其实例:

from car import Car
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23 my_new_car.read_odometer()

出口结果:

2016 Audi A4
This car has 23 miles on it.

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

8.4.2 在贰个模块中积攒多个类

就算如此同二个模块中的类之间应存在某种相关性,但可依赖需求在贰个模块中寄存率性数量的类。类Battery 和ElectricCar 都可支持模拟小车,因而下边将它们都投入模块car.py中:
car.py

"""一组用于表示燃油汽车和电动汽车的类""" 
class Car():
      --snip-- 
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.")
      def get_range(self): 
            """打印一条描述电瓶续航里程的消息""" 
            if self.battery_size == 70:
                  range = 240
            elif self.battery_size == 85:
                  range = 270
            message = "This car can go approximately "   str(range) 
            message  = " miles on a full charge."
            print(message)
class ElectricCar(Car): 
      """模拟电动汽车的独特之处"""
      def __init__(self, make, model, year): 
            """初始化父类的属性,再初始化电动汽车特有的属性"""
            super().__init__(make, model, year) 
            self.battery = Battery()

现行反革命,能够新建壹个名叫my_electric_car.py的文书,导入ElectricCar 类,并成立一辆电动小车了:
my_electric_car.py

from car import ElectricCar
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name()) 
my_tesla.battery.describe_battery() 
my_tesla.battery.get_range()

出口结果:

2016 Tesla Model S
This car has a 70-kWh battery.
This car can go approximately 240 miles on a full charge.

       较长的列表和字典,能够将键值对身处不相同的行里,注意行前缩进

8.4.3 从三个模块中程导弹入多少个类

my_cars.py

from car import Car, ElectricCar
my_beetle = Car('volkswagen', 'beetle', 2016) 
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar('tesla', 'roadster', 2016) 
print(my_tesla.get_descriptive_name())

输出结果:

2016 Volkswagen Beetle 
2016 Tesla Roadster
alien_0={
     'color':'gerrn',
     'points':5,
     'head':'big',
     'phil':'python'}

8.4.4 导入整个模块

您仍是能够导入整个模块,再使用句点表示法访谈须求的类。这种导入方法很简短,代码也便于阅读。由于创设类实例的代码都带有模块名,因而不会与近日文件使用的别的名称发生争持。
my_cars.py

import car
my_beetle = car.Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())
my_tesla = car.ElectricCar('tesla', 'roadster', 2016) 
print(my_tesla.get_descriptive_name())

 

9. 文书和那些

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

9.1 从文件中读取数据

文本文件可存款和储蓄的数据量多得匪夷所思:天气数据、交通数据、社经数据、法学作品等。每当供给解析或涂改存款和储蓄在文件中的新闻时,读取文件都很有用,对数据分析应用程序来讲更是如此。举个例子,你能够编写三个如此的顺序:读取一个文件文件的内容,重新安装这个多少的格式并将其写入文件,让浏览器能够彰显那个剧情。

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

9.1.1 读取全方位文件

要读取文件,必要多个带有几行文本的文件。上边首先来制造叁个文件,它含有正确到小数点后叁十几个人的圆周率值,且在小数点后每11人处都换行:
pi_digits.txt

3.1415926535
   8979323846 
   2643383279

file_reader.py

with open('pi_digits.txt') as file_object: 
      contents = file_object.read() 
      print(contents)

出口结果:

3.1415926535
   8979323846 
   2643383279

相比于原本文件,该出口独一不一致的地方是最后多了贰个空行。为什么会多出这么些空行呢?因为read() 达到文件末尾时重返一个空字符串,而将以此空字符串展现出来时便是叁个空行。要删减多出去的空行,可在print 语句中选取rstrip() :

with open('pi_digits.txt') as file_object: contents = file_object.read() 
print(contents.rstrip())

前边说过,Python方法rstrip() 删除(剥除)字符串末尾的空域。今后,输出与原本文件的内容大同小异:

3.1415926535
   8979323846 
   2643383279

 

9.1.2 文件路线

当你将看似pi_digits.txt这样的轻巧文件名传递给函数open() 时,Python将要当下实施的公文(即.py程序文件)所在的目录中查找文件。
遵照你团队文件的不二秘诀,偶然恐怕要开采不在程序文件所属目录中的文件。比如,你恐怕将顺序文件存款和储蓄在了文本夹python_work中,而在文件夹python_work中,有八个名称叫text_files的文本夹,用于存款和储蓄程序文件操作的公文文件。即使文件夹text_files包蕴在文件夹python_work中,但仅向open() 传递位于该公文夹中的文件的名号也不可行,因为Python 只在文件夹python_work中查找,而不会在其子文件夹text_files中找出。要让Python张开不与程序文件位于同一个目录中的文件,须要提供文件路径,它让Python到系统的一定岗位 去搜索。
出于文件夹text_files位于文件夹python_work中,因而可利用相对文件路径来开采该公文夹中的文件。相对文件路线让Python到钦命的岗位去追寻,而该岗位是相对于当下运作的程 序所在目录的。在Linux和OS X中,你能够那样编写代码:

with open('text_files/filename.txt') as file_object:

这行代码让Python到文件夹python_work下的文书夹text_files中去寻觅内定的.txt文件。在Windows系统中,在文书路径中应用反斜杠( )并不是斜杠(/ ):

with open('text_filesfilename.txt') as file_object:

您还足以将文件在Computer中的正确地点告诉Python,那样就绝不关怀当前运作的主次存款和储蓄在如何地方了。那称之为相对文件路线。在相对路线行不通时,可使用相对路线。举个例子, 如若text_files并不在文件夹python_work中,而在文件夹other_files中,则向open() 传递路线'text_files/ filename.txt' 行不通,因为Python只在文书夹python_work中找找 该职位。为分明地提议你期望Python到哪里去探索,你须要提供全体的门径。
相对路线平常比相对路径越来越长,因而将其储存在八个变量中,再将该变量传递给open() 会有所扶助。在Linux和OS X中,相对路线类似于上边那样:

file_path = '/home/ehmatthes/other_files/text_files/filename.txt' 
with open(file_path) as file_object:

而在Windows系统中,它们就如于上面那样:

file_path = 'C:Usersehmatthesother_filestext_filesfilename.txt' 
with open(file_path) as file_object:

     遍历字典中键       for  变量名 in 字典名.keys()       for name in user_0.keys():
     .keys()方法实质上是重回多个列表,包蕴字典的全体键,因而其还足以用来判别某值是不是在字典的键里

9.1.3 富含一百万位的大型文件

前边大家解析的都以叁个只有三行的文件文件,但那一个代码示例也可管理大得多的文书。若是大家有贰个文本文件,在那之中含有正确到小数点后1000 000位并不是叁十三位的圆周率 值,也可创制三个带有全数这么些数字的字符串。为此,大家不用对后面包车型客车顺序做其余改变,只需将那些文件传递给它就能够。在那边,大家只打印到小数点后伍11人,避防终端为展现全体1 000 000位而不息地翻滚:

filename = 'pi_million_digits.txt'
with open(filename) as file_object: 
      lines = file_object.readlines()
pi_string = ' ' 
for line in lines:
      pi_string  = line.strip()
print(pi_string[:52]   "...") 
print(len(pi_string))

出口评释,我们创建的字符串确实含有正确到小数点后1 000 000位的圆周率值:

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

9.2 写入文件

保留数据的最简便易行的点子之一是将其写入到文件中。通过将出口写入文件,纵然关闭富含程序输出的顶峰窗口,那个输出也照样留存:你能够在程序甘休运维后翻看那么些输出,可与人家分享输出文件,还可编写程序来将这几个输出读取到内部存款和储蓄器中并进行管理。

 

9.2.1 写入空文件

write_message.py

filename = 'programming.txt'
with open(filename, 'w') as file_object:
file_object.write("I love programming.")

programming.txt

I love programming.

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

9.2.2 附加到文件

设若您要给文件加多内容,并非覆盖原有的内容,能够附加格局张开文件。你以附加方式展开文件时,Python不会在回去文件对象前清空文件,而你写入到文件的行都将增多到文件末尾。假诺指定的文件海市蜃楼,Python将为您创建一个空文件。 上边来修改write_message.py,在既有文件programming.txt中再增加一些您热爱编制程序的开始和结果:
write_message.py

filename = 'programming.txt'
with open(filename, 'a') as file_object:
      file_object.write("I also love finding meaning in large datasets.n")
      file_object.write("I love creating apps that can run in a browser.n")

programming.txt

I love programming.
I also love finding meaning in large datasets. 
I love creating apps that can run in a browser.

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

9.3 异常

Python使用被叫做极度的特别规对象来管理程序奉行时期产生的谬误。每当产生让Python力所不及的荒谬时,它都会创立贰个卓殊对象。如若你编写了管理该非常的代码,程序将继 续运营;借令你未对丰盛进行拍卖,程序将告一段落,并彰显多个traceback,个中带有关于至极的告知。
不行是利用try-except 代码块管理的。try-except 代码块让Python试行钦定的操作,同临时候告诉Python爆发卓殊时怎么办。使用了try-except 代码块时,就算出现格外, 程序也将延续运维:呈现你编写的和煦的一无所能音信,并非令客户吸引的traceback。

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

9.3.1 处理ZeroDivisionError 异常

上面来看一种导致Python引发那叁个的简易错误。你只怕清楚无法将四个数字除以0,但大家依然让Python那样做啊:
division.py

print(5/0)

引人注目,Python不可能那样做,由此你将看到二个traceback:

Traceback (most recent call last):
       File "division.py", line 1, in <module>
            print(5/0)
ZeroDivisionError: division by zero

     关于键值重复的难题,键从逻辑上讲是无法重复的,但再一次了不会报错,只会感觉是对键重新赋值,值可以重新

9.3.2 使用try-except代码块

当你认为大概产生了不当时,可编写制定一个try-except 代码块来拍卖或然引发的老大。你让Python尝试运营一些代码,并告诉它一旦这么些代码引发了点名的要命,该如何是好。 管理ZeroDivisionError 十分的try-except 代码块类似于上边那样:

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

输出结果:

You can't divide by zero!

 

9.3.3 使用极度制止崩溃

产生错误时,若是程序还大概有工作尚未完结,妥帖地管理错误就更为关键。这种景色经常会冒出在讲求顾客提供输入的次序中;倘诺程序能够妥帖地处理无效输入,就能够再唤醒客户提供实用输入,而不致于崩溃。
上边来创建一个只进行除法运算的粗略总结器:

print("Give me two numbers, and I'll divide them.") 
print("Enter 'q' to quit.")
while True:
      first_number = input("nFirst number: ")
      if first_number == 'q': 
            break
      second_number = input("Second number: ") 
      if second_number == 'q':
            break
      answer = int(first_number) / int(second_number)
      print(answer)

出口结果:

Give me two numbers, and I'll divide them. 
Enter 'q' to quit.
First number: 5
Second number: 0
Traceback (most recent call last):
      File "division.py", line 9, in <module>
          answer = int(first_number) / int(second_number)
ZeroDivisionError: division by zero

22、print打印的内容较长时,也能够将内容分行写以得到卫生的代码分界面

9.3.4 else代码块

透过将或者引发错误的代码放在try-except 代码块中,可拉长这几个程序抵御错误的技巧。错误是施行除法运算的代码行导致的,因而大家要求将它放到try-except 代码块中。那个示例还隐含多个else 代码块;注重于try 代码块成功进行的代码都应放到else 代码块中:

print("Give me two numbers, and I'll divide them.") 
print("Enter 'q' to quit.")
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)

输出结果:

Give me two numbers, and I'll divide them. 
Enter 'q' to quit.
First number: 5 
Second number: 0
You can't divide by 0!
First number: 5 
Second number: 2 
2.5
First number: q

 

9.3.5 处理FileNotFoundError异常

使用文件时,一种常见的主题材料是找不到文件:你要寻找的文本或然在其他地方、文件名或许不科学恐怕那一个文件根本就空头支票。对于具备那个景况,都可使用try-except 代码块以直观的点子开展拍卖。
作者们来品尝读取贰个荒诞不经的公文。上面包车型客车次第尝试读取文件alice.txt的剧情,但本人尚未将那一个文件存款和储蓄在alice.py所在的目录中:
alice.py

filename = 'alice.txt'
with open(filename) as f_obj: contents = f_obj.read()

Python不可能读取荒诞不经的文书,因而它抓住一个不胜:

Traceback (most recent call last): 
      File "alice.py", line 3, in <module>
          with open(filename) as f_obj:
FileNotFoundError: [Errno 2] No such file or directory: 'alice.txt'

在上述traceback中,最终一行报告了FileNotFoundError 万分,那是Python找不到要开发的公文时创造的要命。在那些示例中,那么些错误是函数open() 导致的,因而要管理 那么些荒唐,必得将try 语句放在满含open() 的代码行在此以前:

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

在这几个示例中,try 代码块引发FileNotFoundError 相当,因而Python搜索与该错误相配的except 代码块,并运转个中的代码。最后的结果是显得一条友好的错误音讯,而不是traceback:

Sorry, the file alice.txt does not exist.

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退出当前循环,重返到循环起来
        注意防止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,不适合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','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

 

    (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_workPythonpi_digits.txt
    过长的门道影响雅观,所以能够将其放在三个变量里

file_path = 'D:code_workPythonpi_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_workPythonpi_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、测量检验代码

 

迎接阅读,有别的不当能够建议,多谢

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:读书笔记,多少个java程序员的python之旅

关键词: