python基础知识（全部）

2023年
说明：如果代码有误的话，记得处理一下缩进，或者注释的问题，文章粘贴的代码在此处可能部分缩进有问题
学习资料：

               3.25 

一 变量和简单数据类型

输出

输入在第七章节

print()

### 字符串

```python
'hello'
"hello"

(1)大小写

字符串s
1.标题：    s.title()
2.大写：    s.upper()
3.小写：    s.lower()

(2)字符串中使用变量

s1="hello"
s2="world"
s3=f"{s1}{s2}"//形式
或者
s3=s1+s2

print(f"hello,{s3.title()}!")

(3)删除空白

1.删除后面的空白
   s.rstrip()//暂时删除
   s=s.rstrip()//永久删除
2.前面的
   s.lstrip()
3.前后
   s.strip()

（4）加法

s="world"
print("hello "+s+"!")
故要将数字加入进去，需要用：str(3) 把3转换为字符串

二 数

整数.浮点数

(1)运算符

+ - * / %（仅两个整数才能使用%）
乘方 ** 
   如：3**2 = 9

（2）同时给多个变量赋值

x,y,z = 1,2,3 

注释

#这是注释
print("haha")

三 列表

列表的元素之间可以没有任何关系

定义和打印

a=[]
bicycle = ['a','b','c']
print(bicycle)
结果：['a','b','c']

访问列表元素

1.a=[1,2,3]
  print(a[0])
  s=['a','b','c']
  print(s[0].title())
2.特殊之处
索引为-1，返回最后一个元素
......-2 ........第二个...

修改，添加，删除元素

修改

a=[1,2,3]
a[0]=0

添加

append()
insert()

（1）末尾添加
     a=[1,2,3]
     a.append(4)#a=[1,2,3,4]
 (2)插入
     a = [1,2,3]
     a.insert(0,1)#a=[1,1,2,3]，0为索引，1为要添加的值

删除

del
pop ()
remove（）

（1）直接删除，不使用

 a = [1,2,3]
 del a[0]

(2)删除，并使用

 a= [1,2,3]
 b = a.pop()#弹出栈顶元素

(3)弹出任何位置的元素

a.pop(0)#0为索引

（4）根据值删除元素

a.remove(2)#2为列表中的一个值

组织列表

sort()
sorted()
s.sort()
sorted(s)
reserve()
len()
(1)永久排序

s = ['a','c','b']
s.sort()#['a','b','c']
s.sort(reverse=True)#['c','b','a']

(2)临时排序

print(sorted(s))#['a','b','c']
print(s)#['a','c','b']

(3)倒着打印

a.reserve()#倒着打印

(4)确定列表长度

len(a)

（5)方法 replace()将字符串中的特定单词都替换为另一个单词。

>>> message = "I really like dogs." 
>>> message.replace('dog', 'cat')

                    2023.3.26 星期日

四 操作列表

循环

形式：
for 变量名 in 数组名:
for语句末尾的冒号告诉Python，下一行是循环的第一行。

a = [1,2,3] 
for i in a: 
   print(i)

缩进

缩进代表for,if…里面的语句，
没有缩进则不代表

创建数值列表

range()
list()#将结果转换为列表

for i in range(1,5)
   print(i)

将range 的列表存储到数字中

（1）
a = list(range(1,5))
print(a)
没有5
（2）
range(2,11,2)
#函数range()从2开始数，然后不断地加2，直到达到或超过终值（11），输出[2,4,6,8,10]
没有12
(3)
 squares = []
 for value in range(1,11):
   square = value**2 
   squares.append(square) 
 print(squares)
 没有11

对数字列表简单的计算

min(a)
max(a)
sum(a)#a为数组名

列表解析

前面介绍的生成列表squares的方式包含三四行代码，而列表解析让你只需编写一行代码就
能生成这样的列表。

squares = [value**2 for value in range(1,11)] 
print(squares)

要使用这种语法，
(1)首先指定一个描述性的列表名，如squares；
(2)然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。在这个示例中，表达式为value^2，它计算平方值。
(2)接下来，编写一个for循环，用于给表达式提供值，再加上右方括号。在这个示例中，or循环为for value in range(1,11)，它将值1~10提供给表达式value^2。请注意，这里的for语句末尾没有冒号。

使用列表的一部分（切片)

切片

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素。

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print(players[0:3])
 形式：
  a[0:3]
 如果你没有指定第一个索引，Python将自动从列表开头开始：
  a[:4]
  a[2:]
 例如，如果你要输出名单上的最后三名队员，可使用切片
  players[-3:]
创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引
  [:]

遍历切片

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print("Here are the first three players on my team:") 
 for player in players[:3]:
 print(player.title())

复制列表

a = [1,2,3]
b = a[:]

例如，下例演示了在不使用切片的情况下复
制列表的情况
b = a

这里将a赋给b，而不是将a的副本存储到b。
这种语法实际上是让Python将新变量b关联到包含在a中的列表，因此这两个变量都指向同一个列表。鉴于此，当我们将4添加到a中时，它也将出现在
b中；同样，虽然’5好像只被加入到了b中，但它也将出现在这两个列表中。

                                   3.27

元组

定义元组

有时候你需要创建一系列不可修改的元素，
元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
元组看起来犹如列表，但使用圆括号而不是方括号来标识。

a=(1,2)
print(a[0])

遍历元组中元素

for i int a:
   print(i)

修改元组变量

虽然不能修改元组的元素，但可以给存储元组的变量赋值

a = (1,2)
a = (3,4)#合法

设置代码格式

缩进：四个空格
行长：<80
空行

五 if 语句

形式：

(1)
if 条件 ：
else :
(2)
if 条件 ：
elif 条件：
elif 条件：
else:（这个else可省略）

比较符号：

< == !=
= <=
与：and
或：or

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

a = 1
if a==1:
    print("yes")
else:
    print("no")

if (a == 1) and (b == 2):
   print("yes")
else:
  print("no")

检查特定值是否包含在列表中

要判断特定的值是否已包含在列表中，可使用关键字in。

c = [1,2,3]

if 4 in c:
    print("that is so good")

else:
    print("oh my god,it is terrible")

检查特定值是否不包含在列表中

not in

确定列表不是空的

在if语句中将列表名用在条件表达式中时，
Python将在列表
至少包含一个元素时返回True，
并在列表为空时返回False。

a = []
if a:
  print("not empty")
else:
  print("empty")

六 字典

使用字典

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

在Python中，字典是一系列键—值对。
如上:'color’为键
’green’为对应的值
每个键都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。
在Python中，字典用放在花括号{}中的一系列键—值对表示，如前面的示例所示：

访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键，如下所示：

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

这将返回字典alien_0中与键’color’相关联的值：
green

alien_0 = {'color': 'green', 'points': 5} 
 new_points = alien_0['points']
 print("You just earned " + str(new_points) + " points!")

上述代码首先定义了一个字典，然后从这个字典中获取与键’points’相关联的值，并将这个值存储在变量new_points中。接下来，将这个整数转换为字符串，并打印一条消息，指出玩家获得了多少个点

添加键—值对

要添加键—值对，可依次指定字典名、用
方括号括起的键和相关联的值。

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

注意，键—值对的排列顺序与添加顺序不同。Python不关心键—值对的添加顺序，
而只关心键和值之间的关联关系。

空字典：
a = {}

删除键—值对

fruit = {'apple' : 'red','banana' : 'yellow'}
print(fruit)

del fruit['apple']
print(fruit)

遍历字典

Python支持对字典遍历。字典可用于以各种方式存储信息，因此有多种遍历字典的方式：可遍历字典的所有键—值对、键或值

遍历所有的键—值对（items()）

要编写用于遍历字典的for循环，可声明两个变量，用于存储键—值对中的键和值。
对于这两个变量，可使用任何名称。

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

for语句的第二部分包含字典名和方法items(），它返回一个键—值对列表。接下来，for循环依次将每个键—值对存储到指定的两个变量中。在前面的示例中，我们使用这两个变量来打印每个键及其相关联的值。第一条print语句中的"\n"确保在输出每个键—值对前都插入一个空行：

遍历字典中的所有键(keys())

(1)在不需要使用字典中的值时，方法**keys()**很有用。下面来遍历字典favorite_languages，并
将每个被调查者的名字都打印出来：

favorite_languages = { 
 'jen': 'python', 
 'sarah': 'c', 
 'edward': 'ruby', 
 'phil': 'python', #注意这里的逗号
 }
for name in favorite_languages.keys():
 print(name.title())

遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for name in favorite_
languages.keys():替换为for name in favorite_languages:，输出将不变。

fruit = {'apple':'red', 'banana' : 'yellow','watermelon' : 'green','grape' :'purple'}

a = ['apple','grape']

for name in fruit.keys():
   print(name)
   if name in a:
    print(name + 'is in a')

                                  3.28

(2) 按顺序遍历字典中的所有键

for a in sorted(fruit.keys()):

遍历字典中的所有值(values())

for s in fruit.values():

为剔除重复项，可使用集合（set）

for s in set(fruit.values()):

嵌套

字典列表

要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套

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)

# 创建一个用于存储外星人的空列表
aliens = [] 
# 创建30个绿色的外星人
 for alien_number in range(30):
 new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
 aliens.append(new_alien)
# 显示前五个外星人
 for alien in aliens[:5]: 
  print(alien) 
# 显示创建了多少个外星人
print("Total number of aliens: " + str(len(aliens)))

for alien in aliens[0:3]: 
 if alien['color'] == 'green': 
   alien['color'] = 'yellow' 
   alien['speed'] = 'medium' 
   alien['points'] = 10

在字典中存储列表

favorite_languages = {
 'jen': ['python', 'ruby'], 
 'sarah': ['c'], 
 'edward': ['ruby', 'go'], 
 'phil': ['python', 'haskell'], #注意这里的逗号
 }

for name, languages in favorite_languages.items():
 print("\n" + name.title() + "'s favorite languages are:") 
for language in languages: 
 print("\t" + language.title())

place = {
    'zhang' : ['yunnan' ,'beijing' ,'shanghai'],
    'li':['fujian','chengdu'],
    'wang' : ['jinlin','shandong'],
    }
for s1,s2 in place.items():
    print(s1 + " likes " + str(len(s2)) + " places,they are :")
    for s in s2:
        print(s)

在字典中存储字典

person = {
    'zhang' : {
       'food' : 'rice',
       'fruit' : 'apple', #注意这里的逗号
    },#注意这里的逗号
    'li' : {
       'food' : 'vegetable',
       'fruit' : 'grape',#注意这里的逗号
    },#注意这里的逗号
}

person = {
    'zhang' : {
       'food' : 'rice',
       'fruit' : 'apple', 
    },
    'li' : {
       'food' : 'vegetable',
       'fruit' : 'grape',
    },
}

for s1,s2 in person.items():
    if s1 == 'li':
        print(s1)
        print(s2)
        s2['food'] = 'meat'
        print(s2)

#结果：
li
{'food': 'vegetable', 'fruit': 'grape'}
{'food': 'meat', 'fruit': 'grape'}

*补充 集合

python–集合

七 用户输入和while循环

python输入方式大全

输入

input()

函数 input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在
一个变量中

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

#final
Tell me something, and I will repeat it back to you: Hello everyone! 
Hello everyone!

prompt = "If you tell us who you are, we can personalize the messages you see." 
prompt += "\nWhat is your first name? " 
name = input(prompt) 
print("\nHello, " + name + "!")

使用 int()来获取数值输入

使用函数input()时，Python将用户输入解读为字符串
函数int()将数字的字符串表示转换为数值表示

height = input()
height = int(height)
#输入为浮点数，用
height = float(height)

                     3.31

while 循环

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

使用 break 退出循环

i = int(input())
flag = True
while flag:
  if i<0:
   flag = False
  else:
   print(i)
  i = int(input())
   

在循环中使用 continue

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

我们首先将current_number设置成了0，由于它小于10，Python进入while循环。进入循环后，
我们以步长1的方式往上数，因此current_number为1。接下来，if语句检查current_number与2的求模运算结果。如果结果为0（意味current_number可被2整除），就执行continue语句，让Python忽略余下的代码，并返回到循环的开头。如果当前的数字不能被2整除，就执行循环中余下的代码，Python将这个数字打印出来：
结果：1 3 5 7 9

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

（1）移动元素

s = [1,2,3,4]
a = []
while(s):
  i = s.pop()
  a.append(i)
for i in a:
  print(i)

（2）删除特定元素

pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
print(pets) 
while 'cat' in pets: 
 pets.remove('cat') 
print(pets)

（3)使用用户输入来填充字典

# 设置一个标志，指出调查是否继续
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 ---")
print(responses)
for name, response in responses.items():
    print(name + " would like to climb " + response + ".")

八 函数

定义函数

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

greet_user()#调用函数

这个示例演示了最简单的函数结构。第一行处的代码行使用关键字def来告诉Python你要定义一个
函数。这是函数定义，向Python指出了函数名，还可能在括号内指出函数为完成其任务需要什么
样的信息。在这里，函数名为greet_user()，它不需要任何信息就能完成其工作，因此括号是空
的（即便如此，括号也必不可少）。最后，定义以冒号结尾。
紧跟在def greet_user():后面的所有缩进行构成了函数体。第二行处的文本是被称为文档字符串
（docstring）的注释，描述了函数是做什么的。文档字符串用三引号括起，Python使用它们来生成有关程序中函数的文档。
代码行print(“Hello!”)是函数体内的唯一一行代码，greet_user()只做一项工作：
打印Hello!。
要使用这个函数，可调用它。函数调用让Python执行函数的代码。要调用函数，可依次指定
函数名以及用括号括起的必要信息。由于这个函数不需要任何信息，因此调用它时
只需输入greet_user()即可。和预期的一样，它打印Hello!

向函数传递信息

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

                  4.1

传递实参

向函数传递实参的方式很多，可使用位置实参，这要求实参的顺序与形参的顺序相同；也可使用关键字实参，其中每个实参都由变量名和值组成；还可使用列表和字典。

位置实参

def fruit_1(type_name,color):
    print("I like " + color  + type_name)

fruit_1('apple','red')
fruit_1('banana','yellow')

请确认函数调用中实参的顺序与函数定义中形参的顺序一致。

关键字实参

关键字实参是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆（不会得到名为Hamster的harry这样的结果）。关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

def fruit_1(type_name,color):
    print("I like " + color  + type_name)

fruit_1(type_name='apple',color='red')
fruit_1(type_name='banana',color='yellow')

默认值

编写函数时，可给每个形参指定默认值。在调用函数中给形参提供了实参时，Python将使用
指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略
相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用法。

def fruit_1(type_name,color = 'yellow'):#默认形参
    print("I like " + color  + type_name)

fruit_1(type_name='apple',color='red')
fruit_1(type_name='banana')

使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参(不可在有默认形参后面加入无默认形参的，会报错)。

def f(a ,b = 0 , c)#error

这让Python依然能够正确地解读位置实参。

返回值

函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值。在函数中，可使用return语句将值返回到调用函数的代码行。返回值让你能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。

返回简单值

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)

返回字典

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

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)

在函数定义中，我们新增了一个可选形参age，并将其默认值设置为空字符串。如果函数调用中包含这个形参的值，这个值将存储到字典中。在任何情况下，这个函数都会存储人的姓名，但可对其进行修改，使其也存储有关人的其他信息。

def get_formatted_name(first_name, last_name,age = ''):
    person = {'first' : first_name,'last' : last_name}
    if age:
        person['age'] = age
    return person
musician = get_formatted_name('jimi', 'hendrix')
age = input("Please input your age:")
zhang = get_formatted_name('zhang','san',age)
print(musician)
print(zhang)

传递列表

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

usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)

禁止函数修改列表

有时候可在函数中修改列表，有时候不希望传进去的函数修改列表。
为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。

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

def f(list_name):
    person = []
    for i in range(3):
        list_name[i] = i
    

list = ['zhang','li','wang']
f(list[:])#传递切片原来列表值不变
print(list)

f(list)#传本身要改变
print(list)

结果：

['zhang','li','wang']
[0,1,2]

传递任意数量的实参

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

形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封
装到这个元组中。函数体内的print语句通过生成输出来证明Python能够处理使用一个值调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用，注意，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')

基于上述函数定义，Python将收到的第一个值存储在形参size中，并将其他的所有值都存储
在元组toppings中。在函数调用中，首先指定表示比萨尺寸的实参，然后根据需要指定任意数量的配料。

def tour(num,*p):
    print(str(num) + " people will go to park, they are:")
    for s in p:
        print(s)

tour(3,'zhang','wang','li')

def food(*p):
    print("client's ingredients")
    for s in p:
        print(s)

a = []
s = input("input your ingredient,if over,please input q:")
while(s!='q'):
    a.append(s)
    s = input()

food(a)

使用任意数量的关键字实参

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种
情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接受多少。一个这样的示例是创建用户简介：你知道你将收到有关用户的信息，但不确定会是什么样的信息。
在下面的示例中，函数build_profile()接受名和姓，同时还接受任意数量的关键字实参：

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)

函数build_profile()的定义要求提供名和姓，同时允许用户根据需要提供任意数量的名称—
值对。形参user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称—值对都封装到这个字典中。在这个函数中，可以像访问其他字典那样访问user_info中的名称—值对。

                             4.2

将函数存储在模块中

函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让
主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。import语句允许在当前运行的程序文件中使用模块中的代码。
通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。
这还能让你在众多不同的程序中重用函数。将函数存储在独立文件中后，可与其他程序员共享这些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库。

导入整个模块

要让函数是可导入的，得先创建模块。模块是扩展名为.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)

making_pizza.py

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

导入特定的函数

一个函数

from module_name import function_name

任意函数

from module_name import function_0, function_1, function_2

示例

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

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

使用 as 给模块指定别名

import pizza as p

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

导入模块中的所有函数

使用星号（*）运算符可让Python导入模块中的所有函数：

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

使用并非自己编写的
大型模块时，最好不要采用这种导入方法：如果模块中有函数的名称与你的项目中使用的名称相
同，可能导致意想不到的结果：Python可能遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有函数

函数编写指南：
给形参指定默认值时，等号两边不要有空格

import出现问题

九 类

python类
python-类

类初始操作

 class Dog():
 """一次模拟小狗的简单尝试"""
  def __init__(self, name, age): #注意这里左右两根线
 """初始化属性name和age""" 
   self.name = name 
   self.age = age 
  def sit(self): #注意括号里面不要少些self
 """模拟小狗被命令时蹲下""" 
   print(self.name.title() + " is now sitting.") 
  def roll_over(self): 
 """模拟小狗被命令时打滚""" 
   print(self.name.title() + " rolled over!")

（1）方法init（）
类中的函数称为方法；你前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。方法__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。
我们将方法__init__()定义成了包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。为何必须在方法定义中包含形参self呢？因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
我们创建Dog实例时，Python将调用Dog类的方法__init__()。我们将通过实参向Dog()传递名字和年龄；self会自动传递，因此我们不需要传递它。每当我们根据Dog类创建实例时，都只需给最后两个形参（name和age）提供值。

class Person():
    def __init__(self,first,second):#C++中为构造函数
        self.first = first
        self.second = second
    def get(self):
        print("Her/His name is " + self.first.title() + self.second.title())
    def change(self):
        s1,s2 = input("What is your name?").split(" ")
        self.first = s1
        self.second = s2

p = Person("zhang","wen jing")#C++中为Person p()
p.get()
p.change()
p.get()

定义的两个变量都有前缀self。以self为前缀的变量都可供类中的所有方法使用，我们
还可以通过类的任何实例来访问这些变量。self.name = name获取存储在形参name中的值，并将其存储到变量name中，然后该变量被关联到当前创建的实例。self.age = age的作用与此类似。

                   4.4

根据类创建实例

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

我们让Python创建一条名字为’willie’、
年龄为6的小狗。遇到这行代码时，Python使用实参’willie’和6调用Dog类中的方法__init__()。
方法__init__()创建一个表示特定小狗的示例，并使用我们提供的值来设置属性name和age。方法__init__()并未显式地包含return语句，但Python自动返回一个表示这条小狗的实例。我们将这
个实例存储在变量my_dog中。

给属性指定默认值

class Car(): 
 def __init__(self, make, model, year): 
 """初始化描述汽车的属性""" 
  self.make = make 
  self.model = model 
  self.year = year
  self.odometer_reading = 0

继承

编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用
继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方
法__init__()需要父类施以援手。

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', 20 16) 


print(my_tesla.get_descriptive_name())

创建子类时，父类必须包含在当前文件中，且位于子类前面。我们定义了子类ElectricCar。定义子类时，必须在括号内指定父类的名称。方法__init__()接受创建Car实例所需的信息

super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用
ElectricCar的父类的方法__init__()，让ElectricCar实例包含父类的所有属性。父类也称为超类（superclass），名称super因此而得名。

class Fruit():
    def __init__(self,type_name,color):
        self.type = type_name
        self.color = color
    def get(self):
        print(self.type + " is " + self.color)

class Son(Fruit):
    def __init__(self,name,color):
        super().__init__(name,color)

apple = Fruit("apple","red")
apple.get()

给子类定义属性和方法

class Car(): 
 --snip-- 
class ElectricCar(Car):  
 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!")

现在，如果有人对电动汽车调用fill_gas_tank()，Python将忽略Car类中的方法fill_gas_tank()，转而运行上述代码。使用继承时，可让子类保留从父类那里继承而来的精华，并剔除不需要的糟粕

class Fruit():
    def __init__(self,type_name,color):
        self.type = type_name
        self.color = color
    def get(self):
        print(self.type + " is " + self.color)

class Son(Fruit):
    def __init__(self,name,color):
        super().__init__(name,color)
        self.i = 12

    def get(self):
        print(self.type + " " + str(self.i))

apple = Fruit("apple","red")
apple.get()

banana = Son("banana","yellow")
banana.get()

运行结果：

apple is red
banana 12

导入类

假设Car类储存在car.py
（1）导入单个类

from car import Car

( 2 )从一个模块中导入多个类

from car import Car,ElectricCar

( 3 )导入整个模块

import car

（4）导入模块中的所有类

from car import *

十 文件

从文件中读取数据

读取整个文件

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

在这个程序中，第1行代码做了大量的工作。
我们先来看看函数open()：
要以任何方式使用文件——哪怕仅仅是打印其内容，都得先打开文件，这样才能访问它。函数open()接受一个参数：要打开的文件的名称。Python在当前执行的文件所在的目录中查找指定的文件。在这个示例中，当前运行的是file_reader.py，因此Python在file_reader.py所在的目录中查找pi_digits.txt。函数open()返回一个表示文件的对象。在这里open(‘pi_digits.txt’)返回一个表示文件pi_digits.txt的对象；Python将这个对象存储在我们将在后面使用的变量中。
关键字with在不再需要访问文件后将其关闭。在这个程序中，注意到我们调用了open()，但没有调用close()；你也可以调用open()和close()来打开和关闭文件，但这样做时，如果程序存在bug，导致close()语句未执行，文件将不会关闭。这看似微不足道，但未妥善地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用close()，你会发现需要使用文件时它已关闭（无法访问），这会导致更多的错误。并非在任何情况下都能轻松确定关闭文件的恰当时机，但通过使用前面所示的结构，可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。
有了表示pi_digits.txt的文件对象后，我们使用方法read()（前述程序的第2行）读取这个文件的全部内容，并将其作为一个长长的字符串存储在变量contents中。这样，通过打印contents的值，就可将这个文本文件的全部内容显示出来

相比于原始文件，该输出唯一不同的地方是末尾多了一个空行。为何会多出这个空行呢？因为read()到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。要删除多出来的空行，可在print语句中使用rstrip()：
Python方法rstrip()删除（剥除）字符串末尾的空白。

文件路径

要让Python打开不与程序文件位于同一个目录中的文
件，需要提供文件路径，它让Python到系统的特定位置去查找。
由于文件夹text_files位于文件夹python_work中，因此可使用相对文件路径来打开该文件夹中的文件。相对文件路径让Python到指定的位置去查找，而该位置是相对于当前运行的程序所在目录的。
windows用（\）

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

绝对路径：

file_path = 'C:\Users\ehmatthes\other_files\text_files\filename.txt' 
with open(file_path) as file_object:

Linux和OS X 用（/）

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

逐行读取

filename = 'pi_digits.txt'
with open(filename) as file_object:
 for line in file_object: 
   print(line)

我们将要读取的文件的名称存储在变量filename中，这是使用文件时一种常见的做法。
由于变量filename表示的并非实际文件——它只是一个让Python知道到哪里去查找文件的字符串，因此可轻松地将’pi_digits.txt’替换为你要使用的另一个文件的名称。
调用open()后，将一个表示文件及其内容的对象存储到了变量file_object中。
这里也使用了关键字with，让Python负责妥善地打开和关闭文件。为查看文件的内容，我们通过对文件对象执行循环来遍历文件中的每一行

结果：
在这个文件中，每行的末尾都有一个看不见的换行符，而print语句也会加上一个换行符，因此每行末尾都有两个换行符：一个来自文件，另一个来自print语句。要消除这些多余的空白行，可在print语句中使用rstrip()

创建一个包含文件各行内容的列表

使用关键字with时，open()返回的文件对象只在with代码块内可用。如果要在with代码块外
访问文件的内容，可在with代码块内将文件的各行存储在一个列表中，并在with代码块外使用该列表：你可以立即处理文件的各个部分，也可推迟到程序后面再处理。

filename = 'pi_digits.txt' 
with open(filename) as file_object: 
  lines = file_object.readlines()
for line in lines:
  print(line.rstrip())

方法readlines()从文件中读取每一行，并将其存储在一个列表中；
接下来，该列表被存储到变量lines中；
在with代码块外，我们依然可以使用这个变量。
我们使用一个简单的for循环来打印lines中的各行。
由于列表lines的每个元素都对应于文件中的一行，因此输出与文件内容完全一致。

读取文本文件时，Python将其中的所有文本都解读为字符串。如果你读取的是数字，并要将其作为数值使用，就必须使用函数int()将其转换为整数，或使用函数float()将其转换为浮点数。

filename = 'pi_million_digits.txt' 
with open(filename) as file_object: 
 lines = file_object.readlines()
 pi_string = '' 
 for line in lines: 
   pi_string += line.rstrip() 

birthday = input("Enter your birthday, in the form mmddyy: ")

if birthday in pi_string:#判断某一字符串是否在大的字符串内
 print("Your birthday appears in the first million digits of pi!") 
else: 
 print("Your birthday does not appear in the first million digits of pi.")

写入文件

写入空文件

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

第一个实参也是要打开的文件的名称；
第二个实参（‘w’）告诉Python，我们要以写入模式打开这个文件。打开文件时，可指定读取模式（‘r’）、写入模式（‘w’）、附加模式（‘a’）或让你能够读取和写入文件的模式（‘r+’）。如果你省略了模式实参，Python将以默认的只读模式打开文件。
如果你要写入的文件不存在，函数open()将自动创建它。然而，以写入（‘w’）模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。

Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str()将其转换为字符串格式。

写入多行

要让每个字符串都单独占一行，需要在write()语句中包含换行符：

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