PYTHON从编程到实践_随笔

PYTHON从编程到实践 2变量和简单数据类型 2.2变量

 变量名只能包含字母、数字和下划线。
变量名不能包含空格，但可使用下划线来分隔其中的单词。
不要将Python关键字和函数名用作变量名
变量名应既简短又具有描述性
慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

2.3字符串

单引号单个，双引号可迭代
第一个大写—print(name.title())
大写----print(name.upper())
小写写—print(name.lower())
合并（拼接）字符串—full_name = first_name + " " + last_name
使用制表符或换行符来添加空白 – print(“Languages:ntPythonntCntJavascript”)
删除空白—favorite_language.rstrip()

2.4数字

可对整数执行加（+）减（-）乘（*）除（/）运算。
使用两个乘号表示乘方运算–3 ** 2
小数点的数字都称为浮点数

使用函数 str()避免类型错误：
将数值23转换为字符串：

age = 23 message = "Happy " + str(age) + "rd Birthday!" 

print(message)

整数除法的结果只包含整数部分，小数部分被删除。确保至少有一个 *** 作数为浮点数，这样结果也将为浮点数：
不要企图编写完美无缺的代码；先编写行之有效的代码，再决定是对其做进一步改进，还是转而去编写新代码。
Python之禅：在 Python终端会话中执行命令 import this，并粗略地浏览一下其他的指导原则。

3列表

用方括号（[]）来表示列表，并用逗号来分隔其中的元素
索引从 0而不是 1开始 ,索引指定为-1返回最后一个列表元素

修改列表元素

 motorcycles = ['honda', 'yamaha', 'suzuki'] 
 print(motorcycles) 

 motorcycles[0] = 'ducati' print(motorcycles)

添加元素
- 在列表末尾添加元素 —motorcycles.append(‘ducati’)
- 在列表中插入元素 — motorcycles.insert(0, ‘ducati’) ，其中0是索引位置
- 从列表中删除元素
  - 使用del语句删除元素，不保留元素— del motorcycles[0]
  - 使用方法pop()删除元素
    方法pop()可删除列表末尾的元素，并让你能够接着使用它
```
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles) 
popped_motorcycle = motorcycles.pop()  
print(motorcycles) 
print(popped_motorcycle)
```
  - d出列表中任何位置处的元素
    每当你使用pop()时，被d出的元素就不再在列表中了。如果你不确定该使用del语句还是pop()方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。
  - 根据值删除元素
    - 不知列表中删除值所处的位置。只知道要删除的元素的值，可使用方法remove
    - 使用remove()从列表中删除元素时，也可接着使用它的值
    - 方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值
```
motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles) 
too_expensive = 'ducati'  
motorcycles.remove(too_expensive) 
print(motorcycles)  
print("nA " + 
too_expensive.title() +
" is too expensive for me.")
```

3.3 组织列表

使用方法 sort()对列表进行永久性排序
- cars.sort()
- cars.sort(reverse=True)
使用函数 sorted()对列表进行临时排序
- 不影响它们在列表中的原始排列顺
- print(sorted(cars))
倒着打印列表
- cars.reverse() print(cars)
- 方法reverse()永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse()即可
确定列表的长度—len()

4. *** 作列表 4.1遍历整个列表

for magician in magicians:
编写for循环时，对于用于存储列表中每个值的临时变量，可指定任何名称。然而，选择描述单个列表元素的有意义的名称大有帮助
忘记缩进会有歧义

4.3创建数值列表

函数range()让Python从指定的第一个值开始数，并在到达指定的第二个值后停止
要创建数字列表，可使用函数list()将range()的结果直接转换为列表

列表与循环语句

squares = [] for value in range(1,11):     
squares.append(value**2) 
与下同
squares = [value**2 for value in range(1,11)]

4.4使用列表的一部分

切片---- print(players[0:3])
最后三名队员，可使用切片players[-3:
遍历切片 ---- for player in players[:3]:
复制列表 — friend_foods = my_foods[:]

       my_foods.append('cannoli')      friend_foods.append('ice cream')   返回的列表不一样

      #这行不通  friend_foods = my_foods ，返回的列表一样

4.5元组

有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组
于试图修改元组的 *** 作是被禁止
先定元组dimensions：dimensions = (200, 50)
遍历元组中的所有值 ----
修改元组变量，虽然不能修改元组的元素，但可以给存储元组的变量赋值
混合使用了制表符和空格，可将文件中所有的制表符转换为空格，大多数编辑器都提供了这样的功能。
建议每行不超过80字符
有5行创建列表的代码，还有3行处理该列表的代码，那么用一个空行将这两部分隔开是合适的。

5.if语句 5.1示例

cars = ['audi', 'bmw', 'subaru', 'toyota'] 
for car in cars:      
    if car == 'bmw':          
        print(car.upper())     
    else:         
        print(car.title())

结果：

Audi 
BMW 
Subaru 
Toyota

5.2条件测试

每条if语句的核心都是一个值为True或False的表达式，这种表达式被称为条件测试
检查是否相等---- car == ‘bmw’
两个大小写不同的值会被视为不相等，将变量的值转换为小写，再进行比较— car.lower() == ‘audi’
检查是否不相等 — !=
- 大多数条件表达式都检查两个值是否相等，但有时候检查两个值是否不等的效率更高
比较数字
检查多个条件
- 1. 使用and检查多个条件
  - 为改善可读性，可将每个测试都分别放在一对括号内----(age_0 >= 21) and (age_1 >= 21)
- 1. 使用or检查多个条件
检查特定值是否包含在列表中，可使用关键字in— ‘mushrooms’ in requested_toppings
检查特定值是否不包含在列表中，可使用关键字not in
布尔表达式

5.3if 语句

示例

    if conditional_test :
        do something

记得缩进

if-else 语句，总是会执行两个 *** 作中的一个

age = 17  
if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")  
else:     
    print("Sorry, you are too young to vote.")     
    print("Please register to vote as soon as you turn 18!")

if-elif-else 结构，经常需要检查超过两个的情形

age = 12 
if age < 4:     
    print("Your admission cost is 使用多个 elif 代码块.")  
elif age < 18:     
    print("Your admission cost is .")  
else:     
    print("Your admission cost is .")

根据缩进判断动作属于该条件或整体的

age = 12 
 
if age < 4:     
    price = 0
elif age < 18:     
    price = 5 
elif age < 65:     
    price = 10  
else:     
    price = 5 
print("Your admission cost is $" + str(price) + ".")

Python并不要求if-elif结构后面必须有else代码块，

省略else 代码块，
- 全部使用elif每个代码块都仅在通过了相应的测试时才会执行
- else是一条包罗万象的语句，只要不满足任何if或elif中的条件测试，其中的代码就会执行，这可能会引入无效甚至恶意的数
- IF EISE只能执行一个条件，满足便停止，可搭配for改善该缺点
测试多个条件：
if-elif-else结构功能强大，但仅适合用于只有一个条件满足的情况：遇到通过了的测试后， Python就跳过余下的测试

requested_toppings = ['mushrooms', 'green peppers', 'extra cheese'] 
 
for requested_topping in requested_toppings:
    if requested_topping == 'green peppers':                   
    print("Sorry, we are out of green peppers right      
    now.")      
    else: 
        print("Adding " + requested_topping + ".") 
 
print("nFinished making your pizza!")

确定列表不是空的

requested_toppings = [] 
 
if requested_toppings:    
    for requested_topping in requested_toppings:             
    print("Adding " + requested_topping + ".")     
    print("nFinished making your pizza!")
else:
    print("Are you sure you want a plain pizza?")

alien_0 = {‘color’: ‘green’, ‘points’: 5}

5.5设置if 语句的格式 6字典 6.1示例

字典是一系列键—值对。每个键都与一个值相关联，可使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典

6.2使用字典

要获取与键相关联的值，可依次指定字典名和放在方括号内的键—print(alien_0[‘color’])
添加键—值对 —alien_0[‘x_position’] = 0
编写能自动生成大量键—值对的代码时，通常都需要先定义一个空字典
修改字典中的值 — alien_0[‘color’] = ‘yellow’
删除键—值对 ,可使用del语句将相应的键—值对彻底删除。使用del语句时，必须指定字典名和要删除的键—del alien_0[‘points’]
由类似对象组成的字典

favorite_languages = {
    'jen': 'python',     
    'sarah': 'c',     
    'edward': 'ruby',     
    'phil': 'python', 
    }

print("Sarah's favorite language is " +                     
    favorite_languages['sarah'].title() + 
     ".")

确定需要使用多行来定义字典时，在输入左花括号后按回车键，再在下一行缩进四个空格，指定第一个键—值对，并在它后面加上一个逗号
将较长的print语句分成多行:

遍历字典中的所有键 —for name in favorite_languages.keys():

6.3遍历字典

遍历所有的键—值对 ----for k, v in user_0.items()
键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系
按顺序遍历字典中的所有键 :函数sorted()来获得按特定顺序排列的键列表的副本—for name in sorted(favorite_languages.keys()):
遍历字典中的所有值 —for language in set(favorite_languages.values()): 剔除重复项，可使用集合（set）。
示例;三嵌套

6.4嵌套

alien_0 = {'color': 'green', 'points': 5} 
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15} 
 
aliens = [alien_0, alien_1, alien_2] 
 
for alien in aliens:
    print(alien)

在字典中存储列表

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

在字典中存储字典

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

示例

7用户输入和while循环 7.1 input()

message = input("Tell me something, and I will repeat it back to you: ")

创建多行字符串的方式。第1行将消息的前半部分存储在变量prompt中；在第2行中，运算符+=在存储在prompt中的字符串末尾附加一个字符串

使用int()来获取数值输入 —age = int(age)
示例
求模运算符 — 6 % 3
如果一个数可被另一个数整除，余数就为0，因此求模运算符将返回0。你可利用这一点来判断一个数是奇数还是偶数：

7.2while 循环

current_number = 1 
while current_number <= 5:
    print(current_number)
    current_number += 1

让用户选择何时退出如果没有可供比较的东西，Python将无法继续运行程序。为解决这个问题，我们必须给变量message指定一个初始值

prompt = "nTell me something, and I will repeat it back to you:" 
prompt += "nEnter 'quit' to end the program. "  
message = ""  
while message != 'quit':     
    message = input(prompt)     
    print(message)

使用标志 :，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为标志.e.g:可让程序在标志为True时继续运行，并在任何事件导致标志的值为False时让程序停止运行

 active = True  
 while active:    
    message = input(prompt)           
    if message == 'quit':         
        active = False      
    else:        
    print(message)

while True:    
    city = input(prompt) 
    
    if city == 'quit':         
        break 
    else:         
        print("I'd love to go to " + city.title() + "!")

使用break 退出循环
-在任何Python循环中都可使用break语句。例如，可使用break语句来退出遍历列表或字典的for循环。

要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue语句

在循环中使用 continue

current_number = 0 
while current_number < 10:      
    current_number += 1   
    if current_number % 2 == 0:       
        continue         
        
    print(current_number)

可按Ctrl + C，也可关闭显示程序输出的终端窗口。

避免无限循环
- 确认程序至少有一个这样的地方能让循环条件为False或让break 语句得以执行。
- 在列表之间移动元素 pop

7.3使用while 循环来处理列表和字典

# 首先，创建一个待验证用户列表 
#  和一个用于存储已验证用户的空列表 
un/confirm/ied_users = ['alice', 'brian', 'candace'] /confirm/ied_users = [] 
 
# 验证每个用户，直到没有未验证用户为止
#  将每个经过验证的列表都移到已验证用户列表中  
while un/confirm/ied_users: 
    current_user = un/confirm/ied_users.pop()         
    
    print("Verifying user: " + current_user.title())   
    /confirm/ied_users.append(current_user)  
    
# 显示所有已验证的用户 
print("nThe following users have been /confirm/ied:") 
for /confirm/ied_user in /confirm/ied_users:                     
    print(/confirm/ied_user.title())

- 分析：
函数pop()以每次一个的方式从列表un/confirm/ied_users末尾删除未验证的用户。由于Candace位于列表un/confirm/ied_users末尾，因此其名字将首先被删除、存储到变量current_user中并加入到列表/confirm/ied_users中

删除包含特定值的所有列表元素—remove()来删除列表中的特定值

使用用户输入来填充字典 —

responses = {} 
 
# 设置一个标志，指出调查是否继续 
polling_active = True 
 
while polling_active:    
    # 提示输入被调查者的名字和回答      
    name = input("nWhat is your name? ")    
    response = input("Which mountain would you like to climb someday? ")          
    
    # 将答卷存储在字典中      
    responses[name] = response     
    
    # 看看是否还有人要参与调查      
    repeat = input("Would you like to let another person respond? (yes/ no) ")    
    if repeat == 'no':        
        polling_active = False          
    # 调查结束，显示结果 
    print("n--- Poll Results ---") 
    for name, response in responses.items():                
        print(name + " would like to climb " + response + ".")

- 注意：首先定义了一个空字典（responses），并设置了一个标志（polling_active），用于指出调查是否继续

向函数传递信息

8函数 8.1定义函数

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

变量username是一个形参——函数完成其工作所需的一项信息

实参和形参
- 值’jesse’是一个实参。实参是调用函数时传递给函数的信息
- 位置实参

8.2 传递实参

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'

- 1. 调用函数多次 
- 2. 位置实参的顺序很重要

关键字实参是传递给函数的名称—值对

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

使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。这让Python依然能够正确地解读位置实参。

默认值
- 默认值放定义函数参数的最后
- 等效的函数调用
避免实参错误
接受名和姓并返回整洁的姓名

8.3返回值

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)

可给实参middle_name指定一个默认值——空字符串，并在用户没有提供中间名时不使用这个实参

让实参变成可选的
- 返回字典

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

结合使用函数和 while 循环

将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的

8.4传递列表

# 首先创建一个列表，其中包含一些要打印的设计 unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron'] completed_models = [] 
 
# 模拟打印每个设计，直到没有未打印的设计为止 
#  打印每个设计后，都将其移到列表completed_models中
while unprinted_designs:    
    current_design = unprinted_designs.pop()   
    
    #模拟根据设计制作3D打印模型的过程    
    print("Printing model: " + current_design) 
    completed_models.append(current_design)  
    
# 显示打印好的所有模型 
print("nThe following models have been printed:")
for completed_model in completed_models:  
    print(completed_model)

- 这个程序还演示了这样一种理念，即每个函数都应只负责一项具体的工作。第一个函数打印 每个设计，而第二个显示打印好的模型；这优于使用一个函数来完成两项工作

切片表示法[:]创建列表的副本

禁止函数修改列表
- 在print_models.py中，如果不想清空未打印的设计列表，可像下面这样调用print_models()：— print_models(unprinted_designs[:], completed_models)
- 下面的函数只有一个形参*toppings，但不管调用语句提供了多少实参，这个形参都将它们统统收入囊中

8.5传递任意数量的实参

def make_pizza(*toppings):    
    """打印顾客点的所有配料"""     
    print(toppings)       
    
make_pizza('pepperoni') 
make_pizza('mushrooms', 'green peppers', 'extra cheese')

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

结合使用位置实参和任意数量实参
- 形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称—值对都封装到这个字典中
使用任意数量的关键字实参
- 导入整个模块— import pizza

8.6将函数存储在模块中

导入特定的函数 —from module_name import function_name
使用as 给函数指定别名 — from module_name import function_name as fn
导入模块中的所有函数—from pizza import *
应给函数指定描述性名称，且只在其中使用小写字母和下划线

8.7 函数编写指南

每个函数都应包含简要地阐述其功能的注释
对于函数调用中的关键字实参，也应遵循这种约定
议代码行的长度不要超过79字符
导致函数定义的长度超过了79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键
示例

9 类 9.1创建和使用类

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

- 根据约定，在Python中，首字母大写的名称指的是类。
- 方法__init__() 
    - 类中的函数称为方法；你前面学到的有关函数的一切都适用于方法
    - 每当你根据Dog类创建新实 例时，Python都会自动运行它
    - 开头和末尾各有两个下划线，这是一种约 定，旨在避免Python默认方法与普通方法发生名称冲突

访问属性—my_dog.name

根据类创建实例

1. 调用方法

class Dog():  
-snip -- 

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

创建多个实例

class Dog():    
-snip -- 

my_dog = Dog('willie', 6) 
your_dog = Dog('lucy', 3)

Car 类

9.2 使用类和实例

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

给属性指定默认值 self.odometer_reading = 0

直接修改属性—my_new_car.odometer_reading = 23
修改属性的值
- 1. 通过方法修改属性的值— def update_odometer(self, mileage):
- 1. 通过方法对属性的值进行递增 —def increment_odometer(self, miles):
- 1. 子类的方法__init__()

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

重写父类的方法

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

将实例用作属性 ??

导入单个类—from car import Car

9.4导入类

在一个模块中存储多个类
从一个模块中导入多个类 —from car import Car, ElectricCar
导入整个模块 — import car
导入模块中的所有类 —from module_name import *
在一个模块中导入另一个模块 —
读取整个文件

9.5 Python标准库 9.6 类编码风格 10.文件和异常 10.1 从文件中读取数据

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

相对路径

文件路径

绝对路径

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

逐行读取
创建一个包含文件各行内容的列表
使用文件的内容
包含一百万位的大型文件

10.2 写入文件

写入多行

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

附加到文件----with open(filename, ‘a’) as file_object:

处理ZeroDivisionError 异常

10.3 异常

使用try-except 代码块 —用户看到的是一条友好的错误消息，而不是traceback
使用异常避免崩溃
else 代码块
处理FileNotFoundError 异常
分析文本 —

title = "Alice in Wonderland" 
title.split() 
['Alice', 'in', 'Wonderland']

使用多个文件

def count_words(filename):   
-snip -- 
 
filenames = ['alice.txt', 'siddhartha.txt', 'moby_dick.txt', 'little_women.txt']
for filename in filenames:  
    count_words(filename)

失败时一声不吭

决定报告哪些错误
使用json.dump()和 json.load()

10.4 存储数据

保存和读取用户生成的数据
重构

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5625248.html

PYTHON从编程到实践

发表评论

评论列表（0条）