Python基础知识（入门）

Python

一、起步

终端操作

• 切换目录--cd

• 显示当前目录所有文件--dir

二、变量和简单数据类型

1.变量的命名和使用

• 变量名只能包含字母、数字、下划线，变量名能以字母或下划线打头，但不能以数字打头

• 变量名不能包含空格，但能使用下划线来分隔其中的单词

• 不要将Python关键字和函数名用作变量名

• 变量名应既简短又具有描述性

• 慎用小写字母l和大写字母O，因为他们容易被看作数字1和0

• 尽量使用小写字母表示变量名，类名或异常名采用每个单词首字母大写的方式，全局或者类常量全部使用大写字母表示，内部使用则使用下划线开头命名

2.字符串

• 方法.title()以首字母大写的方式显示每个字符串，使用全部小写的方式显示字符串 .lower()，使用全部大写的方式显示字符串 .upper()

• first_name = "jiang"
  last_name = "zhao"
  full_name = f"{first_name} {last_name}"
  #这种字符串名为f字符串，f是format(设置格式)的简写

• 空白泛指任何非打印字符，如空格、制表符和换行符

• 在字符串中添加制表符（\t）、换行符（\n）,可在同一个字符串中同时包含制表符和换行符

• 删除字符串末尾多余空白.rstrip(),删除字符串开头多余空白.lstrip,同时剔除字符串两边空白 .strip()

3.整数和浮点数

• python将所有带小数点的数称为浮点数

• 将两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除

• 在任何其他运算中，如果一个操作数是浮点数，Python默认得到的总是浮点数，即便结果原本为整数也是如此

• 可使用下划线将其中的数字分组，例如 a = 14_000_000,并且存储这种数时，Python会忽略其中的下划线，这种方法适用整数和浮点数

4.常量

• Python没有内置的常量类型，但一般用全大写来指出某个变量视为常量

三、列表

1.列表的定义

• 列表由一系列按特定顺序排列的元素组成

2.访问列表元素

• 索引从0开始而不是1

• Python为访问最后一个列表元素提供了一种特殊语法，将最后一个元素索引指定为-1，索引-2返回倒数第二个列表元素，索引-3返回倒数第三个元素，以此类推

3.修改、添加和删除列表元素

• 修改元素直接用索引修改就行，例如

  m = ['a','b','c']
  m[o] = A
  #得到m=['A','b','c']

• 在列表末尾添加元素.append(),动态创建列表：可首先创建一个空列表，用于存储用户将要输入的值，然后将用户提供的每个新值附加到列表中

• 使用方法.insert()可在列表的任何位置添加新元素，为此需要指定新元素的索引和值，例如：

  m = ['a','b','c']
  m.insert(0,'A')
  #得到m=['A','b','c']

• 如果从列表中删除一个元素，且不再以任何的方式使用它，就使用del语句；如果要在删除后继续使用它，就使用方法 .pop(),具体使用：

  m = ['a','b','c']
  del m[o]        #需要知道指定位置
  m1 = m.pop()    #删除列表末尾元素
  m2 = m.pop(0)   #也可以删除指定位置元素

• 根据值删除元素 .remove,只能删除第一个特定的值，如果想要删除的值可能在列表中出现多次，就需要使用循环

  m = ['a','b','c']
  m.remove('a')
  #得到m=['b','c']

4.组织列表

• 使用 .sort()永久地修改列表元素的排列顺序，按字母顺序排列，还可以按与字母顺序相反的顺序排列列表元素，只需要向 sort()传递参数 reverse=True

• 使用函数 sorted()对列表临时排序，同时不影响列表中的原始排列顺序，也可以使用参数 reverse=True按与字母顺序相反的顺序排列列表元素

• 使用 reverse（）方法 倒着打印列表,永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，对列表再次调用 reverse（）方法 即可

• 确定列表的长度，使用函数 len()

5.操作列表

• 编写for循环时，可以依次与列表中每个值相关联的临时变量指定任意名称

• Python通过缩进让代码更易读

• 使用函数 range()创建数字列表，使用方法：

  numbers = list(range(1,5))      #得到1~4的列表
  numbers = list(range(5))        #得到0~4的列表
  numbers = list(range(2,11,2))   
  #得到从2开始间隔为2，最大值不超过11的列表

• 三个专门处理数字列表的Python函数，最大值 max(),最小值 min(),求和 sum()

• 列表解析，例如：s=[a**2 for a in range(1,10)]

• 切片（输出之后还是列表），输出列表前三个元素 a[0:3],如果没有第一个指引，Python将自动从列表开头表示-- a[:4]

• 要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引 [:]

四、元组

1.定义元组

• Python将不能修改的值称为不可变的，而不可变的列表称为元组

• 定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样

• 严格地说，元组是由逗号标识的，圆括号只是让元组看起来更整洁、更清晰

• 定义只包含一个元素的元组，必须在这个元素后面加上逗号

• 创建只包含一个元素的元组通常没有意义，但自动生成的元组有可能只有一个元素

• 相比于列表，元组是更简单的数据结构。如果需要存储一组值在程序的整个生命周期内部不变，就可以使用元组

2.遍历、修改元组

• 像列表一样，也可以使用for循环来遍历元组中的所有值

• 虽然不能修改元组的元素，但是能重新定义整个元组

五、if语句

1.检查多个条件

• 使用and检查多个条件，如果每个测试都通过，整个表达式就为True

• 关键字or也能检查多个条件，但只要至少一个条件满足，就能通过整个测试

2.检查特定值

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

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

3.布尔表达式

布尔表达式的结果要么为True，要么为False

4.注意事项

• Python并不要求if-elif后面必须有else代码块。在优些情况下，else代码块很有用，而在一些其他情况下，使用一条elif语句来处理特定的情形更清晰

• 如果只想执行一个代码块，就使用if-elif-else结构；如果要执行多个代码块，就使用一系列独立的if语句

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

六、字典

1.使用字典

• 字典是一系列键值对，每个键都与一个值相关联

• 与键相关的值可以是数、字符串、列表乃至字典

• 键值对是两个相关联的值，指定键时，Python将返回与之相关联

• 键和值之间用冒号分隔，而键值对之间用逗号分隔

2.访问字典中的值

• 要获取与键相关联的值可依次指定字典名和放在方括号内的键

• 字典中可包含任意数量的键值对

3.添加键值对

字典是一种动态结构，可随时在其中添加键值对，要添加键值对，可依次指定字典名、用方括号括起的键和相关联的值，例如：

alien_0 = {'color':'green','points':5}
alien_0['x_position'] = 0
#得到alien_0 = {'color':'green','points':5,'x_position':0}

使用字典来存储用户提供的数据或者编写能自动生成大量键值对的代码时，通常需要先定义一个空字典。

4.修改字典的值

要修改字典中的值，可依次指定字典名、用方括号括取的键以及与该键相关联的新值，例如： alien_0['color']= ‘yellow'

5.删除键值对

使用 del语句将相应的键值对彻底删除，必须指定字典名和要删除的键，例如 del alien_0['points']

6.使用 get()来访问值

• 使用放在方括号内的键从字典中获取感兴趣的值时，可能会引发问题：如果指定的键不存在就会出错

• 方法 get()的第一个参数用于指定键，是必不可少；第二个参数为指定的键不存在时要返回的值，是可选的

• 如果指定的键有可能不存在，应考虑使用方法 get(),而不使用方括号表示法

• 调用 get()时，如果没有指定第二个参数且指定的键不存在，Python将返回值None。这个特殊值表示没有相应的值，None并非错误。

7.遍历字典

（1）遍历字典中的所有键

• for key,value in user_0.items(),for语句的第二部分包含字典名和方法 items(),它返回一个键值对列表

• 在不需要使用字典中的值时，可使用方法 keys()

• 遍历字典时，会默认遍历所有的键，但是显示地显示方法 keys()更容易理解

（2）按特定顺序遍历字典中的所有键

使用函数 sorted()来获得按特定顺序排列的键列表的副本，例如：

for name in sorted(favorite_languages.keys()):

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

• 使用方法value()来返回一个值列表，不包含任何键，但并未考虑值是否重复

• 为剔除重复项，可使用集合（set），集合中的每个元素都必须是独一无二的

• 当花括号内没有键值对时，定义很可能是集合。不同于列表和字典，集合不会以特定的顺序存储元素

8.嵌套

（1）字典列表

#创建一个用于存储外星人的空列表
aliens = []

#创建30个绿色的外星人
for alien_number in range(30):
	new_alien = {'color':green,'points':5}
	aliens.append(new_alien)

(2)在字典中存储列表

#存储所点披萨的信息
pizza = {
	'crust':'thick',
	'toppings':['mushroom','extra cheese'],
}

#概述所点的披萨
print(f"You ordered a {pizza['crust']}-crust pizza"
		"with the following toppings")
for topping in pizza['toppings']:
	print("\t"+topping)

• 如果函数调用print()中的字符串很长，可以在合适的位置分行，只需在每末尾都加上引号

• 也可以在循环中加上 print("\t"+topping)，在行首加上引号并缩进

（3）在字典中存储字典

#可在字典中将用户名作为键，然后将每位用户信息储存在一个字典中
user = {
	'aeinstein':{
		'first':'albert',
		'last':'einstein',
		
	}
}

七、用户输入和while循环

1.函数input()的工作原理

• 函数 input()接受一个参数--要向用户显示的提示或说明

• 一种创建多行字符串的方式：第一行将消息的前半部分付给变量prompt中。在第二行中，运算符+=在前面赋给变量prompt的字符串末尾附加一个字符串，例如：

  prompt = "if you tell us who you are,we ..."
  prompt += "\nWhat is your first name?"
  #得到
  if you tell us who you are,we...
  what is your first name?

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

可使用函数 int() ,它让Python将输入视为数值，函数 int()将数的字符串表示转换为数值表示

3.求模运算符

求模运算符（%）将两个数相除并返回余数

4.while循环

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

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

• 在循环中使用continue,根据条件测试结果决定是否继续执行，否的话是返回循环的开头，而非像break一样直接退出循环

• 如果程序陷入无限循环，可按Ctrl+C,也可关闭显示程序输出的终端窗口

八、函数

1.定义函数

使用关键字def定义函数,最后定义以冒号结尾，函数调用让Python执行函数的代码，可依次指定函数名以及用圆括号括起的必要信息

2.向函数传递信息

• 传递实参可用位置实参，这要求实参的顺序与形参的顺序相同；也可使用关键字实参，其中每个实参都用变量名和值组成，还可以使用列表和字典

• 在函数中，可根据需要使用任意数量的位置实参，Python将按顺序将函数调用中的实参关联到函数定义中相应的形参

• 关键字实参是传递给函数的名称值对，必须准确指定函数定义中的形参名

• 使用默认值时，必须先在形参列表中列出没有默认值的形参，再列出有默认值的形参

3.返回值

• 函数可返回任何类型的值，包括列表和字典等较复杂的数据结构

• 可将None视为占位值，在条件测试中None相当于False

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

4.传递任意数量的实参

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

  形参名*toppings中星号让Python创建一个名为toppings的空元组，并将所有收到的值都封装到这个元组中，经常看到的通用形参名 *args,它也收集任意数量的位置实参

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

  def build_profile(first,last,**user_info):
  	"""创建一个字典，其中包含我们知道的有关用户的一切"""
  	user_info['first_name'] = first
  	user_info['last_name'] = last
  	return user_info
  	
  user_profile= build_profile('albert','einstein',
  							location='princeton',
  							field='physics')
  print(user_profile)
  #得到{'location':'princeton','field':'physics',
  'first_name':'albert','last_name':'einstein'}

  经常看到的形参名**kwargs,它用于收集任意数量的关键字实参

5.将函数存储在模块中

（1）导入整个模块

• import语句允许在当前运行的程序文件中使用模块中的代码

• 模块是扩展名为.py的文件

（2）导入特定的函数

通过逗号分隔函数名，可根据需要从模块中导入任意数量的函数：

from module_name import function_0,function_1,function_3

(3)使用as给函数和模块指定别名

from pizza import make_pizza as mp
import pizza as p

(4)导入模块中的所有函数

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

from pizza import *

6.函数编写指南

• 编写函数时，应给函数指定描述性名称，且只在其中使用小写字母和下划线

• 每个函数都应包含简要地阐述其功能的注释，该注释应紧跟在函数定义后面

• 给形参指定默认值时，等号两边不要有空格

  def function_name(parameter_0,Paremeter_1='default')

• 对于函数调用中的关键字实参，也应遵循这种约定

• 如果程序或模块包含多个函数，可使用两个空行将相邻的函数分开

• 所有import语句都应该放在文件开头，唯一例外的情形是，在文件开头使用了注释来描述整个程序

九、类

1.创建类

Class Dog:
	"""一次模拟小狗的简单尝试"""
	def __init__(self,name,age):
		""初始化属性name和age"""
		self.name = name
		self.age = age
	
	def sit(self):
		"""模拟小狗收到命令时蹲下"""
		print(f"{self.name} is sitting.")
		
	def roll_over(self):
		"""模拟小狗收到命令时打滚"""
		print(f"{self.name} roll over!")

（1）方法 __init__()

• 类中的函数称为方法，前面学到的有关函数的一切都适用于方法

• Python调用类的方法 __init__会自动传入实参self

• 以self为前缀的变量可供类中的所有方法使用

• 像 self.age = age这样可通过实例访问的变量称为属性

（2）根据类创建实例

my_dog = Dog('willie',6)

（3）访问属性

要访问实例的属性，可使用句点表示法 my_dog.name

（4）调用方法

根据Dog类创建实例后，就能使用句点表示法来调用Dog类中定义的任何方法

2.使用类和实例

创建实例时，有些属性无需通过形参来定义，可在方法__init__()中为其指定默认值，例如 self.odometer_reading = 0

3.修改属性的值

（1）直接修改属性的值

要修改属性的值，最简单的方式是通过实例直接访问它

my_new_car.odometer_reading = 23`

(2)通过方法修改属性的值

无需直接访问属性，可将值传递给方法

def upgrade_odometer(self,mileage):
	"""将里程表读数设置为指定的值"""
	self.odometer_reading = mileage

4.继承

一个类继承另一个类时，将自动获得另一个类所有的属性和方法。子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法。

（1）子类的方法__init__()

创建子类时，父类必须包含在当前文件中，且位于子类前面。定义子类时，必须在圆括号内指定父类的名称。

class ElectriCar(Car):
	#电动汽车的独特之处
	def __init__(self,make,model,year):
        #初始化父类的属性
        #再初始化电动汽车特有的属性
        super().__init__(make,nodel,year)
        self.battery_size = 75

super()是一个特殊的函数，它能够调用父类的方法。

（2）重写父类的方法

对于父类的方法，只要它不符合子类模拟的实物的行为，都可以进行重写。因此可在子类中定义一个与要重写的父类方法同名的方法。这样Python将不会考虑这个父类方法。而只关注你在子类中定义的相应方法。

5.导入类

将类存储在模板中，然后在主程序中导入所需要的模块。

from car import Car						#导入单个类
from car import	Car, ElectricCar		#导入多个类
from module_name import *				#导入模块中的所有类
from electric_car import EletricCar as EC	#使用别名

6.类编码风格

类名采用驼峰命名法，即将类名中的每个单词的首字母都大写而不使用下划线实例名和模块名都采用小写格式，并在单词之间加上下划线。

7.Python标准库

Python标准库是一组模块，我们安装的Python都包含它。下面来看看模块random:

函数 randint(),它将两个整数作为参数，并随机返回一个位于这两个整数之间（含）的整数。

from random import randint
randint(1,6)
#得到3

函数choice(),它将一个列表或者元组作为参数，并随机返回其中的一个元素。

from random import choice
players = ['charles','martina',michael','florence','eli']
first_up = choice(player)
#得到first_up为'eli'

十、文件和异常

（一）读取文件

1.读取整个文件

with open('pi_dights') as file_object
	contens = file_object.read()
print(contens)

函数 open()接受一个参数在所写文件目录中找到需要打开的数据文件，返回一个表示文件的对象。在上面程序中调用了open() 打开文件,而没有使用到 close()关闭文件（更推荐用上面程序所使用的缩进的方法）

使用函数 read()读取这个文件的全部内容，在末尾多返回了一个字符串，但是可在函数调用 print()中使用 rstrip()删除字符串末尾的空白

2.文件路径

显示文件路径时，Windows系统使用反斜杠（\）而不是使用斜杆（/），但在代码中依然可以使用斜杠。

file_path = '/home/ehmatthes/other_files/text_files/filenamme.txt'
#绝对文件路径
with open(file_path) as file_object:
"""相对路径"""
with open('text_files/filename.txt') as file_object:

3.逐行读取

filename = 'pi_dights.txt'

with open(filename) as file_object:
    for line in file_object:
        print(line)

打印每一行时，空白行更多了，一样可以使用函数 rstrip()来删掉空白行

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

file_name = 'pi_digits.txt'

with open(file_name) as file_object:
    lines = file_object.readlines()
for line in lines:
	print(line.rstrip())

函数 readlines()从文件中读取每一行，并将其存储啊一个列表中，列表中的每一个元素对应文件中的一行

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

（二）写入文件

1.写入空文件

filename = 'programming.txt'

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

调用 open() 时提供了两个实参，第一个实参为要打开的文件的名称，第二个实参（'w'）告诉Python要与写入模式打开这个文件。打开文件时,可指定读取模式('r')、写入模式（'w'）、附加模式('a')或读写模式（'r+'）。如果省略了模式实参，Python将以默认的只读模式打开文件。

以写入模式（'w'）打开文件，如果写入的文件不存在，函数 open()将自动创建它；如果写入的文件已经存在，Python将在返回文件对象前清空该文件的内容。

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

函数 write()不会在写入的文本末尾添加换行符，但是可以在调用write()时，在括号里加入换行符。

2.附加到文件

如果要给文件添加内容，而不是覆盖原有的内容，可以以附加模式打开文件。包括文件时，Python不会在返回文件对象时清空文件的内容，而是将写入文件的盘添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。

（三）异常

Python使用称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，他都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行，如果未对异常进行处理。程序将停止并显示traceback,其中包含有关异常的报告。

1.使用try-except代码块

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

2.try-except-else

try:
    answer = int(first_number) / int(second_number)
except ZeroDivisionError:
    print("You can't divide by zero!")
else:
    print(answer)

工作原理为可能引发异常的代码需要放在try语句中，仅在try代码块成功执行时才需要运行的代码放在else代码块中，except代码块告诉Python，如果尝试运行try代码块中的代码时引发了指定的异常怎么办。

3.分析文本

函数 split()以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。结果是一个包含字符串所有单词的列表，虽然有些单词可能包含标点。

filename = 'alice.txt'

try:
	with open(filename,encodeing='utf-8') as f:
		contents = f.read()
except FileNotFoundError:
    print(f"Sorry,the file {filename} does ont exist")
else:
	#计算该文件大致包含多少个单词
    words = contents.split()
    num_words = len(words)
    print(f"The file {filename} has about {num_words} words")
    
    
#结果：The file alice.txt has about 29465 words

4.静默失败

在try-except中的except语句段编写一个pass语句，告诉Python什么都不要做，也不返回traceback,继续执行语句甚至循环

def count_words(filename):
    """计算一个文件大致包含了多少个单词"""
    try:
        --snip--
    except FileNotFoundError:
        pass
    else:
        --snip--
        
filenames = ['alice.txt','siddhartha.txt','moby_dick.txt','little_women.txt']

上面代码出现FileNotFoundError异常时，将执行except代码块中的代码，但什么都不会发生。这种错误发生时，不会出现traceback，也没有任何输出。

如，当'siddhartha.txt'文件找不到时，结果为：

The file alice.txt has about 29465 words.
The file moby_dick.txt has about 29465 words.
The little_women.txt has about 29465 words.

5.重构

代码能够正常地运行，但通过将其划分为一系列完成具体工作的函数，还可以改进，重构让代码更清晰、更易于理解、更容易扩展