Python--基础语法知识

r囧r小猫 2023-01-11 08:33 233阅读 0赞

# Python基础语法知识 #

> 建议有程序语言基础的童鞋阅读，零基础阅读可能会有点费解

[点击下载][Link 1] python最新版本

### 文章目录 ###

*  [ Python基础知识][Python]
 *   *  [注释方法][Link 2]
     *  [数据类型][Link 3]
     *  [输入和输出][Link 4]
     *   *  [输入][Link 5]
         *  [输出][Link 6]
     *  [算数运算符][Link 7]
     *  [常用运算函数][Link 8]
     *  [比较运算符][Link 9]
     *  [逻辑运算符][Link 10]
     *  [成员运算符][Link 11]
     *  [分支][Link 12]
     *  [循环][Link 13]
     *  [列表][Link 14]
     *   *  [列表的取值][Link 15]
         *  [获取元素的下标][Link 16]
         *  [获取列表中多个元素（切片）][Link 17]
         *  [列表的增删改操作][Link 18]
         *   *  [增加][Link 19]
             *  [删除][Link 20]
             *  [修改][Link 21]
         *  [列表的排序][Link 22]
         *  [列表生成式][Link 23]
         *  [列表常用函数][Link 24]
     *  [字典（对象）][Link 25]
     *   *  [字典的创建方式][Link 26]
         *  [字典的常用操作][Link 27]
         *  [获取字典的试图方法][Link 28]
         *  [字典的遍历][Link 29]
         *  [字典的生成式][Link 30]
     *  [元组][Link 31]
     *   *  [元组的创建方式][Link 32]
         *  [元组的遍历][Link 33]
     *  [集合][Link 34]
     *   *  [集合的创建][Link 35]
         *  [集合的常用操作][Link 36]
         *  [集合间的关系][Link 37]
     *  [字符串的常用操作][Link 38]
     *   *  [字符串的查询操作方法][Link 39]
         *  [字符串的大小写转换操作的方法][Link 40]
         *  [字符串内容对齐操作的方法][Link 41]
         *  [字符串分割操作的方法][Link 42]
         *  [判断字符串操作的方法][Link 43]
         *  [字符串操作的其他方法][Link 44]
         *  [字符串格式化操作][Link 45]
         *  [字符串编码和解码操作][Link 46]
     *  [函数][Link 47]
     *   *  [函数的定义和使用][Link 48]
         *  [函数的返回值][Link 49]
         *  [函数的默认值][Link 50]
         *  [函数的参数定义][Link 51]
     *  [python异常处理机制][python]
     *   *  [异常捕获][Link 52]
         *  [异常捕获else][else]
         *  [try...except...else...finally结构][try...except...else...finally]
         *  [python常见的异常类型][python 1]
     *  [类与对象][Link 53]
     *   *  [类的创建][Link 54]
         *  [类实例对象][Link 55]
         *  [动态绑定属性和方法][Link 56]
         *  [面向对象的三大特征][Link 57]
     *  [模块和包][Link 58]
     *   *  [导入模块][Link 59]
         *  [包][Link 60]
     *  [文件的读写][Link 61]
     *   *  [内置函数open()创建文件对象][open]
         *  [常用的文件打开模式][Link 62]
         *  [文件对象的常用方法][Link 63]
         *  [with语句（上下文管理器）][with]
         *  [目录操作 （os 和 os.path）][_os _ os.path]
     *  [python内置模块 ][python 2]

## 注释方法 ##

`# 单行注释`  
`''' 多行注释 '''`

## 数据类型 ##

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>名称</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>chr</code></td> 
   <td>单个字符</td> 
   <td><code>'', 'd'</code></td> 
  </tr> 
  <tr> 
   <td><code>str</code></td> 
   <td>字符串（多个chr）</td> 
   <td><code>'dd', '你好'</code></td> 
  </tr> 
  <tr> 
   <td><code>int</code></td> 
   <td>整数</td> 
   <td><code>1,2,3,4</code></td> 
  </tr> 
  <tr> 
   <td><code>float</code></td> 
   <td>浮点数</td> 
   <td><code>3.1415926</code></td> 
  </tr> 
  <tr> 
   <td><code>bool</code></td> 
   <td>布尔</td> 
   <td><code>Ture, False</code></td> 
  </tr> 
  <tr> 
   <td><code>list</code></td> 
   <td>列表</td> 
   <td><code>[1,2,3,4]</code></td> 
  </tr> 
  <tr> 
   <td><code>tuple</code></td> 
   <td>元组</td> 
   <td><code>('name', 'age')</code></td> 
  </tr> 
  <tr> 
   <td><code>dict</code></td> 
   <td>字典</td> 
   <td><code>{'name':'zzl'}</code></td> 
  </tr> 
  <tr> 
   <td><code>set</code></td> 
   <td>集合</td> 
   <td><code>{'zzl', 'age', 'gender'}</code></td> 
  </tr> 
 </tbody> 
</table>

**查看数据类型函数**  
`type(变量)` 返回该变量的数据类型

**数据类型转换函数**  
`int(num)` 将num转换为整数类型  
`float(num)` 将num转换为浮点数类型  
`bool(num)` 将num转换为布尔类型  
`str(num)` 将num转换为字符串类型

注：

*  int bool float 任何两种类型都可相互转换
 *  任何类型都可以转换为字符串

注：

*  str -> int 要求全部为数字
 *  str -> float 要求全部为数字，且可存在一个小数点

注：当布尔值False转换为str后， 在转换为bool会变成True

## 输入和输出 ##

### 输入 ###

语法 `inp = input('提示文本')`

注：输入结果为str数据类型，如须做其他操作可进行数据转换

### 输出 ###

1、默认输出

print('hello, world')

2、占位符输出

# %s 的s表示变量的数据类型
    print('名字：%s，年龄：%s，性别：%s' % (name, age, sex))

3、推荐使用

print(f'名字：{name}，年龄：{age}，性别：{sex}')

## 算数运算符 ##

`+ - * / ** // %`

前四个同其他编程语言用法相同

--------------------

`**` 表示平方计算 `5 ** 2 === 5的2次方`  
`//` 表示做除运算后取整  
`%` 取余运算

简写形式  
`+= -= *= /= **= //+ %=`

--------------------

注：  
`+` 也可用于字符串拼接  
`*` 当任意一边为字符串时，则表示重复字符串

## 常用运算函数 ##

`round(num, count)` 表示对num四舍五入，并保留小数点后count位

## 比较运算符 ##

`> < >= <= = !=`

常用函数

*  `ord(chr)` 返回该chr的ASCII码(只能为单个字符)
 *  `chr(num)` 返回该ASCII对应的字符

## 逻辑运算符 ##

`and` ，`or` ， `not`

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>and</code></td> 
   <td>真真为真，其他为假（第一项为真则返回第二项的值，如第一项为假则返回第一项的值）</td> 
  </tr> 
  <tr> 
   <td><code>or</code></td> 
   <td>假假为假，其他为真（第一项为真，则返回第一项的值，如第一项为假，则返回第二项的值）</td> 
  </tr> 
  <tr> 
   <td><code>not</code></td> 
   <td>取反</td> 
  </tr> 
 </tbody> 
</table>

## 成员运算符 ##

`in` ，`not in`

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>含义</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>in</code></td> 
   <td>判断某字符是否存在于某字符串</td> 
   <td><code>'h' in 'hello'</code></td> 
  </tr> 
  <tr> 
   <td><code>not in</code></td> 
   <td>判断某字符是否不存在于某字符串</td> 
   <td><code>'h' not in 'hello'</code></td> 
  </tr> 
 </tbody> 
</table>

## 分支 ##

单分支

# 注意缩进
    if bool表达式:  
        print('执行')

双分支

# 注意缩进
    if bool表达式:  
        print('执行语句1')  
    else:
        print('执行语句2')

分支嵌套

# 注意缩进
    if bool表达式:  
        if bool表达式2:
            print('执行嵌套语句')
        else:
            print('执行语句1')  
    else:
        print('执行语句2')

多分支

# 注意缩进
    if bool表达式1:  
        print('执行语句1')  
    elif bool表达式2:
        print('执行语句2')
    elif bool表达式...:
        print('执行语句...')
    else: 
        print('如上都不满足，则执行这条语句')

## 循环 ##

循环控制

> 只能在循环语句中使用，只对距离最近的循环起作用

break # 跳出本循环
    continue # 结束本次循环，执行下一次循环

**while循环**

# 注意判断条件
    while bool表达式:
        print('执行语句')

**for循环**

# range(start, end, rule) 从start开始，到end-1，间隔为rule,rule的正负表示正序或倒序
    # range(1, 11) 输出1~10，不包括最大值11
    # range(1, 11, 2) 输出1~10，不包括最大值11, 第三个参数表示为每次间隔2
    # range(11, 1, -2) 输出11~2，不包括最小值值1, 第三个参数为负数，则表示为倒序且每次间隔2
    # range(5) 简写形式，0~5的范围
    
    for i in range(1,11):
        print(i)

**循环else结构**

> 只有循环完整执行完毕后，才会执行else语句  
> 当循环过程中执行break语句后，else将不执行

# while  
    while bool表达式:  
        print('执行语句')
    else:
        print('while  else语句')
        
    # for  
    for i in range(10):  
        print('执行语句')
    else:
        print('for  else语句')

## 列表 ##

> 对象是存储单个数据的容器，而列表（数组）就是存储多个数据的容器，任何数据类型都可以存放

# 字面量创建新列表
    lst = [1,'2','三']
    
    # 使用list函数创建新列表
    lst = list([1,'2','三'])

### 列表的取值 ###

1.  通过索引下标取值
2.  使用for循环

### 获取元素的下标 ###

1.  list.index(‘元素’) 找不到元素则抛出异常， 可预先使用in方法判断是否存在

### 获取列表中多个元素（切片） ###

`list[start:end:step]`  
从start索引位置开始，截取到end-1位置结束，步长为step

其中step可为负值，表示从start位置往左边截取开始

start默认值为0  
end默认值为列表长度  
step默认值为1

省略参数但 : 必须存在 `list[::]`

### 列表的增删改操作 ###

增加

*  `append(item)`  
    在原有的列表末尾添加一个元素

lst = [10, 20, 30] 
    lst.append(100)
    print(lst) # [10, 20, 30, 100]

*  `extend( [] )`  
    在原有的列表末尾至少添加一个元素，添加元素必须是列表（添加多个）

lst = [10, 20, 30] 
    lst.extend([99, 100])
    print(lst) # [10, 20, 30, 99, 100]

*  `insert(index, item)`  
    在原有的列表指定位置添加一个元素

lst = [10, 20, 30] 
    lst.insert(1, 99)
    print(lst) # [10, 99, 20, 30]

*  切片添加多个元素(指定位置添加多个元素)  
    使用切片把选择到的元素替换掉

lst = [10, 20, 30] 
    lst[1:] = [99]
    print(lst) # [10, 99]

删除

*  `remove(item)`  
    在原有的列表删除一个元素，如果有重复元素只删除一个，如果元素不存在则抛出异常

lst = [10, 20, 30] 
    lst.remove(20)
    print(lst) # [10, 30]

*  `pop(index)`  
    删除指定索引位置的元素，如果指定索引不存在则抛出异常  
    不传index，则删除末尾元素

lst = [10, 20, 30] 
    lst.pop(1)
    print(lst) # [10, 30]

*  `clear()`  
    清空列表

lst = [10, 20, 30] 
    lst.clear()
    print(lst) # []

*  切片删除元素  
    使用切片把选择到的元素替换为空

lst = [10, 20, 30] 
    lst[1:] = []
    print(lst) # [10]

*  删除列表，即释放内存（谨慎使用）

lst = [10, 20, 30] 
    del lst
    print(lst) # 会抛出异常， lst is not defined

*  直接重新赋值

lst = [10, 20, 30] 
    lst[1] = 40
    print(lst) # [10, 40, 30]

*  切片修改（批量修改）

lst = [10, 20, 30] 
    lst[1:3] = [40, 50, 60]
    print(lst) # [10, 40, 50, 60]

### 列表的排序 ###

*  `sort()`  
    在原列表的基础上排序  
    传入reserse=True降序排序  
    传入reserse=False生序升序  
    不传默认升序

# sotr()  
    lst = [9, 3, 2, 8] 
    lst.sort()  
    print(lst) # [2, 3, 8, 9]  
    
    # sotr(reserse=True)  
    lst = [9, 3, 2, 8] 
    lst.sort(reserse=True)  
    print(lst) # [9, 8, 3, 2]
    
    # sotr(reserse=False)  
    lst = [9, 3, 2, 8] 
    lst.sort(reserse=False)  
    print(lst) # [2, 3, 8, 9]

*  `sorted(lst[,rule ])`  
    使用内置函数sorted()进行排序，将产生一个新列表对象  
    传入第二参数reserse=True降序排序  
    传入第二参数reserse=False生序升序  
    不传第二参数默认升序

# sorted(lst)  
    lst = [9, 3, 2, 8] 
    new_list = sorted(lst)  
    print(new_list) # [2, 3, 8, 9]  
    
    # sorted(lst, reserse=True) 
    lst = [9, 3, 2, 8] 
    new_lsit = sorted(lst, reserse=True)  
    print(new_list) # [9, 8, 3, 2]
    
    # sorted(lst, reserse=False)  
    lst = [9, 3, 2, 8] 
    new_lsit = sorted(lst, reserse=False)   
    print(new_list) # [2, 3, 8, 9]

### 列表生成式 ###

*  `[i for i in renge(1, 11)]`  
    列表生成的表达式

lst = [i*i for i in renge(1, 6)]
    print(lst) # [1, 4, 9, 16, 25]

### 列表常用函数 ###

*  len(list)：列表元素个数
 *  max(list)：返回列表元素最大值
 *  min(list)：返回列表元素最小值

## 字典（对象） ##

python的内置数据结构之一，以键值对的方式存储数据。在其他语言中也叫对象。

### 字典的创建方式 ###

*  `info = {'name':'zzl', 'age':18}`
 *  `info = dict(name='zzl', age=18)`

### 字典的常用操作 ###

*  获取字典中的元素

info = {'name':'zzl', 'age':18}  
    
    # []方式
    print(info['name']) # zzl  
    print(info['sex']) # error: keyError 
    
    # get()方式
    print(info.get('name')) # zzl
    print(info.get('sex')) # None  
    print(info.get('sex', '男')) # 如果sex字段为None的话，则打印 '男' 默认值

*  key的判断  
    `in`, `not in`

info = {'name':'zzl', 'age':18}  
    
    # in
    print('name' in info) # True  
    
    # not in
    print('sex' nor in info) # True

*  key的删除

info = {'name':'zzl', 'age':18}  
    
    del info['name'] # 删除name字段
    print(info) # {'age':18}
    
    info.clear() # 清空该字典  
    print(info) # {}

*  新增key

info = {'name':'zzl', 'age':18}  
    info['sex'] = '男'
    print(info) # {'name':'zzl', 'age':18, 'sex':'男'}

*  修改key

info = {'name':'zzl', 'age':18}  
    info['age'] = 20
    print(info) # {'name':'zzl', 'age':20}

### 获取字典的试图方法 ###

*  `keys()`  
    返回字典的所有key组成的列表

info = {'name':'zzl', 'age':18}  
    keys = info.keys()
    print(keys) # ['age', 'name']

*  `values()`  
    返回字典的所有value组成的列表

info = {'name':'zzl', 'age':18}  
    values = info.value()
    print(values) # [18, 'zzl']

*  `items()`  
    返回字典的所有key:value组成的列表

info = {'name':'zzl', 'age':18}  
    itmes = info.items()
    print(items) # [('age', 18), ('name', 'zzl')]

### 字典的遍历 ###

info = {'name':'zzl', 'age':18}  
    
    for item in info:
        print(item，info[item])
    # age 'zzl'
    # name 18

### 字典的生成式 ###

items = ['Fruits', 'Books', 'Others'] 
    prices = [98, 97, 95] 
    d = { item:price for item, price in zip(items, prices) }
    print(d) # {'Others': 95, 'Books': 97, 'Fruits': 98}

**字典的特点**

1.  字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
2.  字典中的元素是无序的
3.  字典中的key必须是不可变对象，（即key不能为变量）
4.  字典也可以根据需要动态的伸缩
5.  字典会浪费较大的内存，是一种使用空间换时间的数据结构

## 元组 ##

> 列表的另一种形式，是不可变序列

### 元组的创建方式 ###

# 直接用小括号书写
    t = ('python', 'world', '20') 
    
    # 使用内置函数tuple() 
    t1 = tuple( ('python', 'world', '20') )
    
    t3 = ('python',) # 如果元组只有一个元素，则在元素后面加上 ，  
    
    # 获取元组的元素
    t[0] # python

### 元组的遍历 ###

t = ('python', 'world', '20') 
    
    for item in t:
        print(item)
    # python
    # world 
    # 20

注：

1.  如果元组中对象本身是不可变对象，则不能再引用其他对象
2.  如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

## 集合 ##

> python语言提供的内置数据结构  
> 与列表、字典都属于可变类型的序列  
> 集合是没有value的字典  
> 集合的存储是无序的

### 集合的创建 ###

# 集合的value不能重复
    s = {2, 3, 4, 5, 2, 4} 
    print(s)  # {2,3,4,5}
    
    # set()函数  
    s1 = set(range(6)) 
    print(s1) # set([0, 1, 2, 3, 4, 5])
    
    s2 = set([1,2,3,5,6,4,3])
    print(s2) # set([1, 2, 3, 4, 5, 6])
    
    s3 = set((1,23,5,32,1))
    print(s3) # set([32, 1, 5, 23])
    
    s4 = set('python')  
    print(s4) # set(['h', 'o', 'n', 'p', 't', 'y'])
    
    s5 = set({12,4,23,4,12})  
    print(s5) # set([12, 4, 23])
    
    # 定义集合
    s6 = set()

### 集合的常用操作 ###

s = {10, 20, 30, 40, 50}   
    
    # 判断是否存在
    print(10 in s) # True   
    print(70 in s) # False
    
    # 新增  
    s.add(80) 
    print(s) # {10, 20, 30, 40, 50, 80}  
    
    # 新增多个  
    s.update({200, 400})  
    print(s) # {10, 20,, 200, 30, 40, 50, 400, 80}  
    
    # 删除  
    s.remove(10) 
    print(s) # {20,, 200, 30, 40, 50, 400, 80} 
    s.remove(900) # error: keyError
    s.discard(900) # 如果有则删除900， 没有也不会报错
    s.pop() # 随机删除一个， 不能传参  
    s.clear() # 清空集合

### 集合间的关系 ###

两个集合是否相等（判断集合中的元素是否完全相等）

s1 = {10, 20, 30, 40}
    s2 = {20, 40, 10, 20} 
    print(s1 == s2) # True
    print(s1 != s2) # False

一个集合是否是另一个集合的子集

> 假如集合s1的元素里包括集合s2的全部元素，则s2是s1的子集

s1 = {10, 20, 30, 40}
    s2 = {20, 40} 
    print(s2.issubset(s1)) # True

一个集合是否是另一个集合的超集

> 与上相反，假如集合s1的元素里包括集合s2的全部元素，则s1是s2的超集

s1 = {10, 20, 30, 40}
    s2 = {20, 40} 
    print(s1.issuperset(s2)) # True

一个集合和另一个集合是否无交集

> 如果一个集合里某个元素，在另一个集合里也有存储，则两个集合有交集

s1 = {10, 20, 30, 40}
    s2 = {80, 60} 
    print(s1.isdisjoint(s2)) # False 无交集

## 字符串的常用操作 ##

### 字符串的查询操作方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>index()</td> 
   <td>查找子串第一次出现的位置，如果查找的子串不存在时，则抛出ValueError</td> 
  </tr> 
  <tr> 
   <td>rindex()</td> 
   <td>查找子串最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError</td> 
  </tr> 
  <tr> 
   <td>find()</td> 
   <td>查找子串第一次出现的位置，如果查找的子串不存在时，则返回-1</td> 
  </tr> 
  <tr> 
   <td>rfind()</td> 
   <td>查找子串最后一次出现的位置，如果查找的子串不存在时，则返回-1</td> 
  </tr> 
 </tbody> 
</table>

### 字符串的大小写转换操作的方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>upper()</td> 
   <td>把字符串中所有字符都转成大写字母</td> 
  </tr> 
  <tr> 
   <td>lower()</td> 
   <td>把字符串中所有字符都转成小写字母</td> 
  </tr> 
  <tr> 
   <td>swapcase()</td> 
   <td>把字符串中所有大写字母转成小写字母，把所有小写字母转成大写字母</td> 
  </tr> 
  <tr> 
   <td>capitalize()</td> 
   <td>把第一个字符转换为大写，其余字符小写</td> 
  </tr> 
  <tr> 
   <td>title()</td> 
   <td>把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写</td> 
  </tr> 
 </tbody> 
</table>

### 字符串内容对齐操作的方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>center()</td> 
   <td>居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串</td> 
  </tr> 
  <tr> 
   <td>ljust()</td> 
   <td>左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串</td> 
  </tr> 
  <tr> 
   <td>rjust()</td> 
   <td>右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串</td> 
  </tr> 
  <tr> 
   <td>zfill()</td> 
   <td>右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果设置宽度小于实际宽度，则返回原字符串</td> 
  </tr> 
 </tbody> 
</table>

### 字符串分割操作的方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>split(cha, max)</td> 
   <td>从字符串的左边开始分割，默认分割符是空格，返回值是一个列表，第一个参数为分割符，第二个参数为最大分割次数</td> 
  </tr> 
  <tr> 
   <td>split(cha, max)</td> 
   <td>从字符串的右边开始分割，默认分割符是空格，返回值是一个列表，第一个参数为分割符，第二个参数为最大分割次数</td> 
  </tr> 
 </tbody> 
</table>

### 判断字符串操作的方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>isidentifier()</td> 
   <td>判断指定字符串是不是合法的标识符</td> 
  </tr> 
  <tr> 
   <td>isspace()</td> 
   <td>判断指定字符串是否由空白字符组成（回车、换行、水平制表符tab）</td> 
  </tr> 
  <tr> 
   <td>isalpha()</td> 
   <td>判断指定字符串是否全部由字母组成</td> 
  </tr> 
  <tr> 
   <td>isdecimal()</td> 
   <td>判断指定字符串是否全部由十进制的数字组成</td> 
  </tr> 
  <tr> 
   <td>isnumeric()</td> 
   <td>判断指定字符串全部由数字组成</td> 
  </tr> 
  <tr> 
   <td>isalnum()</td> 
   <td>判断指定字符串是否全部由字母和数字组成</td> 
  </tr> 
 </tbody> 
</table>

### 字符串操作的其他方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>replace()</td> 
   <td>第1个参数指定被替换的子串<br> 第2个参数指定替换子串的字符串<br> 该方法返回替换后的字符串，替换前的字符串不会发生变化<br> 该方法的第3个参数可以指定最大替换次数</td> 
  </tr> 
  <tr> 
   <td>cha.join(lst)</td> 
   <td>用<code>cha</code>将列表后元组的字符串合并成一个字符串。使用方法为<code>cha.join(lst)</code></td> 
  </tr> 
 </tbody> 
</table>

### 字符串格式化操作 ###

# %s 的s表示数据类型  s:字符串  i:整数
    print('我叫%s，我今年%i岁' % ('zzl', 18)) # 我叫zzl，我今年18岁'
    
    # {}里的数字表示后面变量的索引，可重复使用
    print('我叫{0}，我今年{1}岁，我真的叫{0}'.format('zzl', 18)) # 我叫zzl，我今年18岁，我真的叫zzl'
    
    # 前面加f  可在{}中直接填写变量
    print(f'我叫{'zzl'}，我今年{18}岁') # 我叫zzl，我今年18岁'

### 字符串编码和解码操作 ###

# 编码
    
    s = '好好学习，天天向上'
    # 使用GBK格式进行编码, 此格式中，一个中文占两个字节
    print(s.encode(encoding='GBK')) #b'\xba\xc3\xba\xc3\xd1\xa7\xcf\xb0\xa3\xac\xcc\xec\xcc\xec\xcf\xf2\xc9\xcf'
    
    # 使用UTF-8格式进行编码 此格式中，一个中文占三个字节
    print(s.encode(encoding='UTF-8')) #b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0\xef\xbc\x8c\xe5\xa4\xa9\xe5\xa4\xa9\xe5\x90\x91\xe4\xb8\x8a'
    
    
    
    # 解码  （使用什么格式编码，就必须使用什么格式解码，否则会报错）
    
    # 使用GBK格式进行编码
    print(s.encode(encoding='GBK').decode(encoding='GBK')) # 好好学习，天天向上
    
    # 使用UTF-8格式进行编码
    print(s.encode(encoding='UTF-8').decode(encoding='UTF-8')) # 好好学习，天天向上

## 函数 ##

### 函数的定义和使用 ###

# 定义
    def 函数名(a, b): # 参数a和b
        函数体  
        return  # 返回值  
        
    # 使用  
    函数名()  
    
    # 代码演示  
    def cals(a, b):
        c = a + b 
        return c
        
    res = cals(20, 30) # 50

**函数的参数传递**

*  位置传参，`cals(20, 30)` ，此时a的值是20， b的值是30
 *  关键字传参， `cals(b=70, a=30)` 此时a的值是30， b的值是70

### 函数的返回值 ###

1.  如果函数没有返回值（函数执行完毕之后，不需要给调用处提供数据）,return可以省略不写
2.  函数的返回值，如果是1个，直接返回原值
3.  函数的返回值，如果是多个，返回的结果为元组

def fun(lst):
        odd = [] # 存放奇数  
        even = [] # 存放偶数
        for i in lst:
            if (i%2) :
                odd.append(i)
            else:
                even.append(i)
        return odd,even
    
    lst = [10, 23, 65, 78, 32, 77] 
    print(fun(lst)) # ([23, 65, 77], [10, 78, 32])

### 函数的默认值 ###

在定义函数的时候，可以给形参赋上默认值，当没传参数的时候，函数会取默认值，如果传参和默认值同时存在，传的参数会替换掉默认值

def cals(a, b = 10):
        c = a + b 
        return c
        
    res = cals(20) # 30  
    res = cals(20, 30) # 50

### 函数的参数定义 ###

*  个数可变的位置参数  
    定义函数时，可能无法确定传递的实参个数，这个时候就要使用可变的位置形参。使用\*定义，结果为一个元组

def fun(*args);
        print(args)
    
    fun(1)  # (1,)
    fun(1,2,3)  # (1, 2, 3)

*  个数可变的关键字参数（指定参数名传递参数）  
    定义函数时，可能无法确定传递的关键字实参个数，这个时候就要使用可变的关键字形参。使用\*定义，结果为一个字典

def fun(**args);
        print(args)
    
    fun(a=10)  # {'a':10}
    fun(a=10, b=20, c=30)  # {'a':10, 'b':20, 'c':30}

以上参数在函数定义时，一种方式只能定义一次。  
当两种参数定义方式同时存在时，位置形参必须在关键字形参前面

## python异常处理机制 ##

### 异常捕获 ###

try:
        可能出现异常的语句放在这里 
    except 你要捕获的异常类型:
        捕获到异常后你想做什么
    except 你要捕获的异常类型:
        捕获到异常后你想做什么
    ...
    except BaseException as e: # 这种情况是以上异常类型都没捕获到，则执行这块代码
        print('出错了', e)
    print('程序照常执行')

### 异常捕获else ###

try:
        可能出现异常的语句放在这里 
    except 你要捕获的异常类型:
        捕获到异常后你想做什么
    except 你要捕获的异常类型:
        捕获到异常后你想做什么
    ...
    except BaseException as e: # 这种情况是以上异常类型都没捕获到，则执行这块代码
        print('出错了', e)
    else:
        print('如果没有异常则执行else部分')

### try…except…else…finally结构 ###

try:
        a = int(input('请输入第一个整数'))
        b = int(input('请输入另一个整数'))
        res = a/b
    except BaseException as e:
        print('出错了', e)
    else:
        print('结果为:'res)
    finlly:
        print('无论是否产生异常，总会被执行的代码')

### python常见的异常类型 ###

<table> 
 <thead> 
  <tr> 
   <th>异常类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ZeroDivisionError</td> 
   <td>除零or向零取余</td> 
  </tr> 
  <tr> 
   <td>IndexError</td> 
   <td>序列中没有此索引</td> 
  </tr> 
  <tr> 
   <td>KeyError</td> 
   <td>映射中没有这个键</td> 
  </tr> 
  <tr> 
   <td>NameError</td> 
   <td>未声明or未定义</td> 
  </tr> 
  <tr> 
   <td>SyntaxError</td> 
   <td>语法错误</td> 
  </tr> 
  <tr> 
   <td>ValueError</td> 
   <td>传入无效的参数</td> 
  </tr> 
 </tbody> 
</table>

## 类与对象 ##

### 类的创建 ###

*  类属性: 类中方法外的变量称为类属性，被该类的所有实例对象共享
 *  类方法: 使用`@classmethod`修饰的方法，可使用类名直接访问
 *  静态方法: 使用`@staticmethod`修饰的方法，可使用类名直接访问

# Stubent为类的名称，由一个或多个单词组成。（建议类名书写方式为每个单词首字母大写）
    class Student:
        native_pace = '河南' # 直接写在类里的变量，称为属性
        
        # 初始化函数( 构造函数 )
        def __init__(self, name ,age):
            # 创建实例的时候 对name和age属性进行赋值
            self.name = name
            self.age = age
        
        # 定义在类里面的方法为实例方法
        def eat(self):
            print('吃饭')
        
        # 静态方法 （静态方法里不允许写self）
        @staticmethod 
        def method():
            print('使用staticmethod进行修饰，所以我是静态方法')
            
            
        # 类方法
        @classmethod 
        def cm(cls):
            print('使用calssmethod进行修饰，所以我是类方法')

### 类实例对象 ###

# 类实例创建语法  stu = Student()
    # 假设已存在上面的 Student 类  
    
    # stu1就是Student类的实例对象，该实例对象中可以访问到类中的属性和方法
    stu1 = Student('zzl', 18) # 创建实例
    print(stu1.name) # zzl
    print(stu1.age) # 18
    stu1.eat() # 吃饭

### 动态绑定属性和方法 ###

# 假设已存在Student类  
    stu = Student('zzl', 18)  
    
    # 绑定 gender 属性 
    stu.gender = '男' 
    print(stu.gender) # 男
    
    # 绑定 show 方法
    def show():
        print('show方法执行')
    stu.show = show
    stu.show() # show方法执行

### 面向对象的三大特征 ###

*  封装 （提高程序的安全性）  
    将数据（属性）和行为（方法）封装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法。这样无需关心方法内部的具体实现细节，从而隔离了复杂度。在python中没有专门的修饰符用户属性的私有化，如果该属性不想被类对象访问，可以在属性名前面加两个 ‘\_’
 *  继承
 *  多态

代码演示

# 继承
    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def info(self):
            print(self.name, self.age)
    
    
    class Student(Person):
        def __init__(self, name, age, stu_no):
            super().__init__(name, age)
            self.stu_no = stu_no
    
    
    class Teacher(Person):
        def __init__(self, name, age, teachofyear):
            super().__init__(name, age)
            self.teachofyear = teachofyear
    
    
    stu = Student('张三', 20, 10001)
    teacher = Teacher('李四', 35, 10)
    
    stu.info() # 张三 20
    teacher.info() # 李四 35
    
    # python 支持多继承 
    class A(class1, class2):  
        pass
        
    # 方法重写  
    # 方法重写就是在子类里定义与父类重名的方法，这样就会优先调用子类的定义的方法

## 模块和包 ##

> 定义：每一个.py文件就是一个模块

使用模块化的好处

1.  方便其他程序和脚本的导入使用
2.  避免函数名和变量名冲突
3.  提高代码的可维护性
4.  提高代码的可重用性

### 导入模块 ###

# 导入模块
    import 模块名称 [as 别名]  
    
    # 导入模块中的指定函数(or 变量 or 类)
    from 模块名称 import 函数/变量/类

### 包 ###

> 包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下

作用

1.  代码规范
2.  避免模块名称冲突

包与目录的区别

1.  包含\_\_init\_\_.py文件的目录称为包
2.  目录里通常不存在\_\_init\_\_.py文件

包的导入  
`import 包名.模块名`

## 文件的读写 ##

### 内置函数open()创建文件对象 ###

# file = open( filename, [mode, encoding] )
    
    # 假设有一个名为a的文本文件，里面有hello world
    file = open('a.txt', 'r')
    print(file.readlines()) # ['hello world']
    file.close()

### 常用的文件打开模式 ###

<table> 
 <thead> 
  <tr> 
   <th>打开模式</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>r</td> 
   <td>以只读模式打开文件，文件的指针将会放在文件的开头</td> 
  </tr> 
  <tr> 
   <td>w</td> 
   <td>以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头</td> 
  </tr> 
  <tr> 
   <td>a</td> 
   <td>以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容</td> 
  </tr> 
  <tr> 
   <td>b</td> 
   <td>以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb,后者wb</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>以读写方式打开文件，不能单独使用，需要与其他模式一起使用，如a+</td> 
  </tr> 
 </tbody> 
</table>

### 文件对象的常用方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>read([size])</td> 
   <td>从文件中读取size个字节或字符的内容返回，若省略size，则读取到文件末尾，即一次读取文件所有内容</td> 
  </tr> 
  <tr> 
   <td>readline()</td> 
   <td>从文本文件中读取一行内容</td> 
  </tr> 
  <tr> 
   <td>readlines()</td> 
   <td>把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回</td> 
  </tr> 
  <tr> 
   <td>write(str)</td> 
   <td>将字符串str内容写入文件</td> 
  </tr> 
  <tr> 
   <td>writelines(s_list)</td> 
   <td>将字符串列表s_list写入文本文件，不添加换行符</td> 
  </tr> 
  <tr> 
   <td>seek(offset[, whence])</td> 
   <td>把文件指针移动到新的位置，offset表示相对与whence的位置：<br> offset：为正则往结束方向移动，为负则往开始方向移动<br> whence不同的值代表不同含义：<br> 0：从文件头开始计算（默认值）<br> 1：从当前位置开始计算<br> 2：从文件末尾开始计算</td> 
  </tr> 
  <tr> 
   <td>tell()</td> 
   <td>返回文件指针的当前位置</td> 
  </tr> 
  <tr> 
   <td>flush()</td> 
   <td>把缓冲区的内容写入文件，但不关闭文件</td> 
  </tr> 
  <tr> 
   <td>close()</td> 
   <td>把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源</td> 
  </tr> 
 </tbody> 
</table>

### with语句（上下文管理器） ###

> with语句可以自动管理上下文资源，不论什么原因跳出with语句都能确保文件正确的关闭，以此来达到释放资源的目的

# with使用  
    with open(filename, mode) as file:
        pass

### 目录操作 （os 和 os.path） ###

1.  os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样
2.  os模块与os.path模块用于对目录或文件进行操作

import os
    # 打开计算器
    os.system('calc.exe')
    # 打开记事本
    os.system('notepad.exe')
    
    # 打开可执行文件
    os.startfile('路径')

os模块操作目录相关函数

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getcwd()</td> 
   <td>返回当前的工作目录</td> 
  </tr> 
  <tr> 
   <td>listdir(path)</td> 
   <td>返回指定路径下的文件和目录信息</td> 
  </tr> 
  <tr> 
   <td>mkdir(path[, mode])</td> 
   <td>创建目录</td> 
  </tr> 
  <tr> 
   <td>makedirs(path1/path2…[, mode])</td> 
   <td>创建多级目录</td> 
  </tr> 
  <tr> 
   <td>rmdir(path)</td> 
   <td>删除目录</td> 
  </tr> 
  <tr> 
   <td>removedirs(path1/path2…)</td> 
   <td>删除多级目录</td> 
  </tr> 
  <tr> 
   <td>chdir(path)</td> 
   <td>将path设置为当前工作目录</td> 
  </tr> 
 </tbody> 
</table>

os.path模块操作目录相关函数

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>abspath(path)</td> 
   <td>用于获取文件或目录的绝对路径</td> 
  </tr> 
  <tr> 
   <td>exists(path)</td> 
   <td>用于判断文件或目录是否存在，如果存在返回True,否则返回False</td> 
  </tr> 
  <tr> 
   <td>join(path, name)</td> 
   <td>将目录与目录，或者目录与文件名连接起来</td> 
  </tr> 
  <tr> 
   <td>split(path)</td> 
   <td>分离目录和文件名</td> 
  </tr> 
  <tr> 
   <td>splittext(name)</td> 
   <td>分离文件名和扩展名</td> 
  </tr> 
  <tr> 
   <td>basename(path)</td> 
   <td>从一个目录中提取文件名</td> 
  </tr> 
  <tr> 
   <td>dirname(path)</td> 
   <td>从一个路径中提取文件路径，不包括文件名</td> 
  </tr> 
  <tr> 
   <td>isdir(path)</td> 
   <td>判断是否为路径</td> 
  </tr> 
 </tbody> 
</table>

## python内置模块 ##

使用`import`关键字引入

<table> 
 <thead> 
  <tr> 
   <th>模块</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>random</td> 
   <td>随机数生成</td> 
  </tr> 
  <tr> 
   <td>traceback</td> 
   <td>处理异常</td> 
  </tr> 
  <tr> 
   <td>sys</td> 
   <td>与python解释器及环境操作相关的标准库</td> 
  </tr> 
  <tr> 
   <td>time</td> 
   <td>提供与时间相关的各种函数的标准库</td> 
  </tr> 
  <tr> 
   <td>os</td> 
   <td>提供了访问操作系统服务功能的标准库</td> 
  </tr> 
  <tr> 
   <td>calendar</td> 
   <td>提供与日期相关的各种函数的标准库</td> 
  </tr> 
  <tr> 
   <td>urllib</td> 
   <td>用于读取来自网上（服务器）数据的标准库</td> 
  </tr> 
  <tr> 
   <td>json</td> 
   <td>用于使用JSON序列化和反序列化对象</td> 
  </tr> 
  <tr> 
   <td>re</td> 
   <td>用于在字符串中执行正则表达式匹配和替换</td> 
  </tr> 
  <tr> 
   <td>math</td> 
   <td>提供标准算术运算函数的标准库</td> 
  </tr> 
  <tr> 
   <td>decimal</td> 
   <td>用于进行精准控制运算精度、有效数位和四舍五入操作的十进制运算</td> 
  </tr> 
  <tr> 
   <td>logging</td> 
   <td>提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能</td> 
  </tr> 
 </tbody> 
</table>

（原文：[Python基础知识学习][Python 1]，感谢博友！）

[Link 1]: https://www.python.org/downloads/release/python-391/
[Python]: https://blog.csdn.net/weixin_48179599/article/details/112942692#Python_0
[Link 2]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_5
[Link 3]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_9
[Link 4]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_43
[Link 5]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_45
[Link 6]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_51
[Link 7]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_69
[Link 8]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_89
[Link 9]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_93
[Link 10]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_101
[Link 11]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_110
[Link 12]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_118
[Link 13]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_163
[Link 14]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_213
[Link 15]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_224
[Link 16]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_228
[Link 17]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_231
[Link 18]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_243
[Link 19]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_244
[Link 20]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_274
[Link 21]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_315
[Link 22]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_330
[Link 23]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_377
[Link 24]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_385
[Link 25]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_391
[Link 26]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_394
[Link 27]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_398
[Link 28]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_450
[Link 29]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_473
[Link 30]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_483
[Link 31]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_499
[Link 32]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_502
[Link 33]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_515
[Link 34]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_532
[Link 35]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_538
[Link 36]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_566
[Link 37]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_592
[Link 38]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_629
[Link 39]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_630
[Link 40]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_638
[Link 41]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_647
[Link 42]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_655
[Link 43]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_661
[Link 44]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_671
[Link 45]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_677
[Link 46]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_691
[Link 47]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_715
[Link 48]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_716
[Link 49]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_739
[Link 50]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_760
[Link 51]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_771
[python]: https://blog.csdn.net/weixin_48179599/article/details/112942692#python_797
[Link 52]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_798
[else]: https://blog.csdn.net/weixin_48179599/article/details/112942692#else_812
[try...except...else...finally]: https://blog.csdn.net/weixin_48179599/article/details/112942692#tryexceptelsefinally_827
[python 1]: https://blog.csdn.net/weixin_48179599/article/details/112942692#python_841
[Link 53]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_853
[Link 54]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_854
[Link 55]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_887
[Link 56]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_900
[Link 57]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_917
[Link 58]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_964
[Link 59]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_974
[Link 60]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_983
[Link 61]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_998
[open]: https://blog.csdn.net/weixin_48179599/article/details/112942692#open_999
[Link 62]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_1009
[Link 63]: https://blog.csdn.net/weixin_48179599/article/details/112942692#_1019
[with]: https://blog.csdn.net/weixin_48179599/article/details/112942692#with_1033
[_os _ os.path]: https://blog.csdn.net/weixin_48179599/article/details/112942692#__os__ospath_1042
[python 2]: https://blog.csdn.net/weixin_48179599/article/details/112942692#python_1083
[Python 1]: https://blog.csdn.net/weixin_48179599/article/details/112942692