python基础知识(全部)

2023年
说明:如果代码有误的话,记得处理一下缩进,或者注释的问题,文章粘贴的代码在此处可能部分缩进有问题
学习资料:python基础知识(全部)_第1张图片

目录

    • 一 变量和简单数据类型
      • 输出
    • 二 数
        • 整数.浮点数
      • 注释
    • 三 列表
      • 定义和打印
      • 访问列表元素
      • 修改,添加,删除元素
        • 修改
        • 添加
        • 删除
        • 组织列表
    • 四 操作列表
      • 循环
      • 缩进
      • 创建数值列表
      • 对数字列表简单的计算
      • 列表解析
      • 使用列表的一部分(切片)
        • 切片
        • 遍历切片
        • 复制列表
      • 元组
        • 定义元组
        • 遍历元组中元素
        • 修改元组变量
        • 设置代码格式
    • 五 if 语句
        • 比较符号:
        • 检查特定值是否包含在列表中
        • 检查特定值是否不包含在列表中
        • 确定列表不是空的
    • 六 字典
      • 使用字典
        • 访问字典中的值
        • 添加键—值对
        • 删除键—值对
      • 遍历字典
        • 遍历所有的键—值对(items())
        • 遍历字典中的所有键(keys())
        • 遍历字典中的所有值(values())
      • 嵌套
        • 字典列表
        • 在字典中存储列表
        • 在字典中存储字典
    • *补充 集合
    • 七 用户输入和while循环
      • 输入
        • input()
        • 使用 int()来获取数值输入
      • while 循环
        • 使用 break 退出循环
        • 在循环中使用 continue
      • 使用 while 循环来处理列表和字典
    • 八 函数
      • 定义函数
        • 向函数传递信息
      • 传递实参
        • 位置实参
        • 关键字实参
        • 默认值
      • 返回值
        • 返回简单值
        • 返回字典
      • 传递列表
      • 禁止函数修改列表
      • 传递任意数量的实参
        • 结合使用位置实参和任意数量实参
        • 使用任意数量的关键字实参
      • 将函数存储在模块中
        • 导入整个模块
        • 导入特定的函数
        • 使用 as 给函数指定别名
        • 使用 as 给模块指定别名
        • 导入模块中的所有函数
      • import出现问题
    • 九 类
      • 类初始操作
        • 根据类创建实例
        • 给属性指定默认值
      • 继承
        • 给子类定义属性和方法
        • 重写父类的方法(函数)
      • 导入类
    • 十 文件
      • 从文件中读取数据
        • 读取整个文件
        • 文件路径
        • 逐行读取
        • 创建一个包含文件各行内容的列表
      • 写入文件
        • 写入空文件
        • 写入多行

               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)
没有52range(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)

禁止函数修改列表

有时候可在函数中修改列表,有时候不希望传进去的函数修改列表。
为解决这个问题,可向函数传递列表的副本而不是原件;这样函数所做的任何修改都只影响副本,而丝毫不影响原件。
python基础知识(全部)_第2张图片

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

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基础知识(全部)_第3张图片

九 类

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

你可能感兴趣的:(python,python,开发语言)