Python基础语法——编程规范、变量、运算符、基础数据类型

布满荆棘的人生 2022-01-31 14:29 430阅读 0赞

### 文章目录 ###

*  编程规范
 *   *  行与缩进
     *  注释
     *  多行语句
     *  输入与输出
     *  空行
     *  导入模块
     *  help函数
     *  函数与方法
 *  变量
 *  运算符
 *   *  算数运算符
     *  比较运算符
     *  赋值运算符
     *  位运算符
     *  逻辑运算符
     *  成员运算符
     *  身份运算符
     *  运算符的优先级
 *  基础数据类型
 *   *  Number数字数据类型
     *   *  数字类型之间的转换
         *  数学函数
         *  随机数函数
         *  三角函数
         *  数学常量
     *  String字符串类型
     *   *  索引：
         *  截取字符串
         *  更新字符串
         *  转义字符
         *  字符串运算符
         *  字符串格式化
         *  Python三引号
         *  字符串中的内置函数
     *  List列表
     *   *  访问列表中的值
         *  更新列表
         *  列表脚本操作符
         *  列表的嵌套
         *  列表函数及方法
     *  Tuple元组
     *  Dictionary字典
     *   *  访问字典中的值
         *  更新字典
         *  字典键的特性
         *  字典内置函数&方法
     *  Set集合

*  参考教程：[https://www.runoob.com/python3][https_www.runoob.com_python3]

# 编程规范 #

## 行与缩进 ##

python最具特色的就是使用缩进来表示代码块。  
缩进的空格数是可变的，但是**同一个代码块的语句必须包含相同的缩进空格数**。

## 注释 ##

*  单行注释：`# 单行注释`

# 这是一条单行注释

*  多行注释：`'''多行注释'''` `"""多行注释"""`

'''
    多行注释的第一种方法
    多行注释的第一种方法
    '''
    
    """
    多行注释的第二种方法
    多行注释的第二种方法
    """

## 多行语句 ##

python通常在一行写完一条语句，如果语句太长，可以分行写，在行末加上`\`即可：

sum = number1 + \
    	  number2 + \
    	  number3

在`{}` `[]` `()`里面的多行语句，不需要加`\`  
python也可以在一行显示多条语句，语句之间用`;`隔开

## 输入与输出 ##

*  输入：

input("等待用户输入")

*  输出：

# python中默认是换行输出的
    print("a")
    print("b")
    # 想要不换行输出，加上 end="" 就可以
    print("a",end=" ")
    print("b",end=" ")

## 空行 ##

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

## 导入模块 ##

1.  `import xxx`  
    导入某个模块
2.  `from xxx import aaa`  
    导入某个模块的某个函数
3.  `from xxx import aaa,bbb,ccc`  
    导入某个模块的多个函数
4.  `from xxx import *`  
    导入某个模块的所有函数

## help函数 ##

调用 python 的 help() 函数可以打印输出一个函数的文档字符串：

>>> help(max)
    Help on built-in function max in module builtins:
    
    max(...)
        max(iterable, *[, default=obj, key=func]) -> value
        max(arg1, arg2, *args, *[, key=func]) -> value
        
        With a single iterable argument, return its biggest item. The
        default keyword-only argument specifies an object to return if
        the provided iterable is empty.
        With two or more arguments, return the largest argument.

## 函数与方法 ##

值得注意的是python中方法和函数时有区别的：

1.  区别一：所处的位置

函数是直接写在文件中而不是class中的，方法只能写在class中。

1.  区别二：二者的定义方式不同

函数定义的方式 def关键字 然后接函数名 再是括号 括号里面写形参也可以省略不写形参

方法定义的方式 首先方法是定义在类中的其他他大体和函数定义差不多，方法必须带一个默认参数(相当于this)，静态方法除外。

1.  区别三：二者的调用方式不同

函数的调用：函数名(参数1,参数2,…)

方法的调用：对象实例.方法(参数) （这里是指对象方法）

# 变量 #

**Python 中的变量不需要声明**。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

name = "bob"	# String类型
    age = 19	# 整型
    salary = 10000.0	# 浮点型

python同样支持连等给多个变量同时赋值：

1.  赋同一个值

a = b = c = 1

1.  赋不同的值

a, b, c = 1, 2, 3

# 运算符 #

## 算数运算符 ##

一般的运算符

`+`加 `-`减 `*`乘 `%`取余

python都支持，python中比较特殊的是：

*  `/` 除 （这个符号在java中给整型用有整除的用法）

>>> print (4/3)
    1.3333333333333333

但是java中输出4/3就是1（和python中的//用法类似）

*  `**` 返回幂次方

>>> print (2 ** 4)
    16

*  `//` 整除

>>> print (10 // 3)
    3

// 并不一定总是返回一个整数类型的值，它与分支分母的数据类型有关系：

>>> print (10 // 3.0)
    3.0
    >>> print (10.0 // 3)
    3.0

## 比较运算符 ##

*  `==` 比较对象是否相等
 *  `!=` 比较两个对象是否不相等
 *  `>` 大于
 *  `<` 小于
 *  `>=` 大于等于
 *  `<=`小于等于

## 赋值运算符 ##

*  `=` 赋值
 *  `+=` 加法赋值运算符 a+=b 等效于 a = a+b 其他类似
 *  `-=` 减法赋值运算符
 *  `*=`乘法赋值运算符
 *  `/=`除法赋值运算符
 *  `%=`取余赋值运算符
 *  `**=`幂赋值运算符
 *  `//=`整除赋值运算符

## 位运算符 ##

按位运算符是把所有的数字当做二进制来计算的。

*  `&` \-**按位与**  
    参与运算的两个值，如果相应位都为1，那么结果值相应位为1，否则为0
 *  `|` \-**按位或**  
    参与运算的两个值，只要有一个为1，那么结果就为1
 *  `^` \-**按位异或**  
    当两相应的二进制相异时结果为1
 *  `~` \-**按位取反**  
    对数据的每个二进制取反 1 相互转换 0  
    ~x类似于-x-1，比如 ~3 = -3-1 = -4
 *  `<<` \-**左移**  
    运算数的各二进制位全部左移若干位，由`<<`右边的数指定移动的位数，高位丢弃，低位补0。相当于给原数乘以2的n次幂。比如5<<2 = 5 \* （2 \*\* 2）= 5 \*4 =20
 *  `>>` \-**右移**  
    把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数

## 逻辑运算符 ##

*  `and` 布尔与
 *  `or` 布尔或
 *  `not` 布尔非

优先级：not > and > or

在python中，逻辑运算返回的值并不限定于True / False。

python中的任何数据类型都有逻辑值，所以逻辑运算符可以对所有数据进行操作。

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>False</th> 
   <th>True</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>整型</td> 
   <td>0</td> 
   <td>其他</td> 
  </tr> 
  <tr> 
   <td>浮点型</td> 
   <td>0.0</td> 
   <td>其他</td> 
  </tr> 
  <tr> 
   <td>字符串</td> 
   <td>‘’</td> 
   <td>其他</td> 
  </tr> 
  <tr> 
   <td>字典</td> 
   <td>{}</td> 
   <td>其他</td> 
  </tr> 
  <tr> 
   <td>元组</td> 
   <td>()</td> 
   <td>其他</td> 
  </tr> 
  <tr> 
   <td>列表</td> 
   <td>[]</td> 
   <td>其他</td> 
  </tr> 
  <tr> 
   <td>None</td> 
   <td>None</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

*  举例

1.  `A and B`  
    case 1：A 是 False ，返回 A（所以python的逻辑与是短路与）。  
    case 2：A 是 True，返回 B 。

> 理解：可以这么理解，与的话要两个参数都为真才返回真，那么就会先判断A，A 为假就直接返回假（A），A为真那么结果就取决于B的真假，返回B就可以。

1.  `A or B`  
    case 1：A 是 False，返回 B  
    case 2：A 是 True，返回 A

> 理解：和and反着来，或的话就要求只要有一个为真就返回真，先判断A ，A 为 真 就直接返回真（A），A 为假那么结果就取决于B，返回B。

1.  `not A`  
    case 1：A 是 False，返回 True  
    case 2：A 是 True，返回 False

> 理解：这个没什么好说的，取反就可以了

## 成员运算符 ##

Python还支持一些成员运算符，成员包括字符串，列表和元祖。

*  `in`  
    如果在指定的序列中找到值则返回True，否则返回False
 *  `not in`  
    如果在指定的序列中没有找到值返回 True，否则返回 False。

## 身份运算符 ##

身份运算符用于比较两个对象的存储单元是否相同。

*  `is`  
    判断两个标识符是否引用自同一个对象
 *  `is not`  
    判断两个标识符是不是引用自不同对象

> `id()`函数用来获取对象的内存地址，`x is y`， 类似 `id(x) == id(y)` ；`x is not y` ， 类似 `id(a) != id(b)`

*  is 和 == 的区别

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

list = [1,2,3]
    list2 = list3 = list
    print(list2 is list3) # True
    print(list2 == list3) # True
    
    list2 = ['a','b','c']
    list3 = ['a','b','c']
    
    print(list2 is list3) # False
    print(list2 == list3) # True

## 运算符的优先级 ##

以下表格列出了从最高到最低优先级的所有运算符：

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>**</td> 
   <td>指数 (最高优先级)</td> 
  </tr> 
  <tr> 
   <td>~ + -</td> 
   <td>按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)</td> 
  </tr> 
  <tr> 
   <td>* / % //</td> 
   <td>乘，除，取模和取整除</td> 
  </tr> 
  <tr> 
   <td>+ -</td> 
   <td>加法减法</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt; &lt;&lt;</td> 
   <td>右移，左移运算符</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>位 ‘AND’</td> 
  </tr> 
  <tr> 
   <td>^|</td> 
   <td>位运算符</td> 
  </tr> 
  <tr> 
   <td>&lt;= &lt; &gt; &gt;=</td> 
   <td>比较运算符</td> 
  </tr> 
  <tr> 
   <td>&lt;&gt; == !=</td> 
   <td>等于运算符</td> 
  </tr> 
  <tr> 
   <td>= %= /= //= -= += *= **=</td> 
   <td>赋值运算符</td> 
  </tr> 
  <tr> 
   <td>is is not</td> 
   <td>身份运算符</td> 
  </tr> 
  <tr> 
   <td>in not in</td> 
   <td>成员运算符</td> 
  </tr> 
  <tr> 
   <td>and or not</td> 
   <td>逻辑运算符</td> 
  </tr> 
 </tbody> 
</table>

# 基础数据类型 #

Python3 中有六个标准的数据类型：

1.  **Number**（数字）
2.  **String**（字符串）
3.  **List**（列表）
4.  **Tuple**（元组）
5.  **Set**（集合）
6.  **Dictionary**（字典）

其中：

*  不可变数据（3 个）：

**Number（数字）、String（字符串）、Tuple（元组）；**

*  可变数据（3 个）：

**List（列表）、Dictionary（字典）、Set（集合）。**

> 使用功能**type**()函数可以查看变量所指的对象类型此外还可以用**isinstance**()函数来判断类型，二者的区别是，type()函数不会认为子类是一种父类类型，isinstance()函数会认为子类是一种父类类型。

## Number数字数据类型 ##

Python3中支持的数字类型有：**int**，**float**，**bool**，**complex**

*  **int** 整数类型，长整型，是正或负的整数，不带小数点，可以用十六进制或者八进制表示
 *  **float** 浮点型，整数+小数，可以用科学计数法表示，比如1.234e4
 *  **bool** 布尔型，0表示False，其余表示True
 *  **complex** 复数，实部加虚部构成，可以用a+bj或者complex(a,b)表示，其中a和b都是float

### 数字类型之间的转换 ###

Python中数据类型的转换非常简单，你只需要将数据类型作为函数名即可。

*  **int(x)** 将x转换为整数，x不能为复数
 *  **float(x)** 将x转换为一个浮点数，x不能为复数
 *  **complex(x)** 将x转换到一个复数，实数部分为 x，虚数部分为 0。
 *  **complex(x, y)** 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

### 数学函数 ###

使用前导入math模块：import math

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>返回值 ( 描述 )</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>abs(x)</td> 
   <td>返回数字的绝对值，如abs(-10) 返回 10</td> 
  </tr> 
  <tr> 
   <td>ceil(x)</td> 
   <td>返回数字的上入整数，如math.ceil(4.1) 返回 5</td> 
  </tr> 
  <tr> 
   <td>exp(x)</td> 
   <td>返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045</td> 
  </tr> 
  <tr> 
   <td>fabs(x)</td> 
   <td>返回数字的绝对值，如math.fabs(-10) 返回10.0</td> 
  </tr> 
  <tr> 
   <td>floor(x)</td> 
   <td>返回数字的下舍整数，如math.floor(4.9)返回 4</td> 
  </tr> 
  <tr> 
   <td>log(x)</td> 
   <td>如math.log(math.e)返回1.0,math.log(100,10)返回2.0</td> 
  </tr> 
  <tr> 
   <td>log10(x)</td> 
   <td>返回以10为基数的x的对数，如math.log10(100)返回 2.0</td> 
  </tr> 
  <tr> 
   <td>max(x1, x2,…)</td> 
   <td>返回给定参数的最大值，参数可以为序列。</td> 
  </tr> 
  <tr> 
   <td>min(x1, x2,…)</td> 
   <td>返回给定参数的最小值，参数可以为序列。</td> 
  </tr> 
  <tr> 
   <td>modf(x)</td> 
   <td>返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。</td> 
  </tr> 
  <tr> 
   <td>pow(x, y)</td> 
   <td>x**y 运算后的值。</td> 
  </tr> 
  <tr> 
   <td>round(x [,n])</td> 
   <td>返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。</td> 
  </tr> 
  <tr> 
   <td>sqrt(x)</td> 
   <td>返回数字x的平方根。</td> 
  </tr> 
 </tbody> 
</table>

示例：

import math
    
    # 绝对值
    print(abs(-10))         # 10
    # 向上取整
    print(math.ceil(2.1))   # 3
    # e的x次幂
    print(math.exp(2))      # 7.38905609893065
    # 取绝对值
    print(math.fabs(-10.3)) # 10.3
    # 向下取整
    print(math.floor(4.9))  # 4
    # 对数计算
    print(math.log(100,10)) # 2.0
    # lg
    print(math.log10(1000)) # 3.0
    # 最大值
    print(max(1,2,3,4,5))   # 5
    # 最小值
    print(min(1,2,3,4,5))   # 1
    # 指数运算
    print(pow(3,3))         # 27
    # 求近似值,保留两位小数
    print(round(math.pi,2)) # 3.14
    # 求近似值,四舍五入取整
    print(round(math.pi))   # 3
    # 平方根
    print(math.sqrt(4))     # 2.0

### 随机数函数 ###

随机数可以用于数学，游戏，安全等领域，还经常被嵌入到算法中，可以提交算法效率，并提交程序的安全性。

使用时`import random`

python中包含以下随机数函数：

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>choice(seq)</td> 
   <td>从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。</td> 
  </tr> 
  <tr> 
   <td>randrange ([start,] stop [,step])</td> 
   <td>从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1</td> 
  </tr> 
  <tr> 
   <td>random()</td> 
   <td>随机生成下一个实数，它在[0,1)范围内。</td> 
  </tr> 
  <tr> 
   <td>seed([x])</td> 
   <td>改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。</td> 
  </tr> 
  <tr> 
   <td>shuffle(lst)</td> 
   <td>将序列的所有元素随机排序</td> 
  </tr> 
  <tr> 
   <td>uniform(x, y)</td> 
   <td>随机生成下一个实数，它在[x,y]范围内。</td> 
  </tr> 
 </tbody> 
</table>

示例：

import random
    
    # choice 从序列中随机挑选元素
    print(random.choice(range(10)))             # 随机返回0-9中间的某个数
    
    # start – 指定范围内的开始值，包含在范围内。
    # stop – 指定范围内的结束值，不包含在范围内。
    # step – 指定递增基数。
    print(random.randrange(1,100,2))            # 随机返回1-99中间的奇数
    
    print(random.random())                      # 随机生成0-1之间的实数
    
    # 所谓假Random，是指所返回的随机数字其实是一个稳定算法所得出的稳定结果序列，
    # 而不是真正意义上的随机序列。 Seed就是这个算法开始计算的第一个值。
    # 所以就会出现只要seed是一样的，那么后续所有“随机”结果和顺序也都是完全一致的。
    random.seed(10)
    print(random.random())
    random.seed(10)
    print(random.random())                      # 生成两个一样的随机数
    
    # 将参数序列随机排列
    indexList=[1,2,3,4,5]
    random.shuffle(indexList)
    print(indexList)                            # 随机排列1-5
    
    # 在指定的范围内生成实数
    print(random.uniform(1,10))                 # 随机生成1-10之间的实数

### 三角函数 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>acos(x)</td> 
   <td>返回x的反余弦弧度值。</td> 
  </tr> 
  <tr> 
   <td>asin(x)</td> 
   <td>返回x的反正弦弧度值。</td> 
  </tr> 
  <tr> 
   <td>atan(x)</td> 
   <td>返回x的反正切弧度值。</td> 
  </tr> 
  <tr> 
   <td>atan2(y, x)</td> 
   <td>返回给定的 X 及 Y 坐标值的反正切值。</td> 
  </tr> 
  <tr> 
   <td>cos(x)</td> 
   <td>返回x的弧度的余弦值。</td> 
  </tr> 
  <tr> 
   <td>hypot(x, y)</td> 
   <td>返回欧几里德范数 sqrt(x<em>x + y</em>y)。</td> 
  </tr> 
  <tr> 
   <td>sin(x)</td> 
   <td>返回的x弧度的正弦值。</td> 
  </tr> 
  <tr> 
   <td>tan(x)</td> 
   <td>返回x弧度的正切值。</td> 
  </tr> 
  <tr> 
   <td>degrees(x)</td> 
   <td>将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0</td> 
  </tr> 
  <tr> 
   <td>radians(x)</td> 
   <td>将角度转换为弧度，x为角度</td> 
  </tr> 
 </tbody> 
</table>

### 数学常量 ###

*  pi 圆周率
 *  e 自然常数

import math
    print(math.pi)
    print(math.e)

## String字符串类型 ##

使用`'`或者`"`来给变量赋值即可创建字符串。

使用`\`转义特殊字符，使用r可以让`\`失效。

字符串可以用 `+` 拼接，也可以用 `*` 重复 。

python的字符串有两种索引方式，有左往右从0开始，从右往左从-1开始。

python中的字符串是不能改变的，通过索引改变字符串的某个字符是无效的。

python中没有单个字符的概念，单个字符也会被看做字符串。

### 索引： ###

![在这里插入图片描述][20190517131315121.png]

### 截取字符串 ###

1.  `[n]` 表示截取第n+1个字符
2.  `[n:m]` 表示截取从第n+1个字符开始，到第m个字符中间的所有字符（包含n+1和m）
3.  `[n:]` 表示截取n后面的所有字符
4.  `[:n]` 表示截取从第一个字符开始，到第n个字符中间的所有字符

>>> str = "abcdef"
    
    >>> print(str[0])  # 输出第一个字符
    a
    >>> print(str[-2]) # 输出倒数第二个字符
    e
    >>> print(str[0:]) # 输出从第一个字符开始后的所有字符
    abcdef
    >>> print(str[1:5]) # 输出从第二个字符开始，到第五个字符中间的所有字符
    bcde
    >>> print(str[1:-1]) # 输出从第二个字符开始，到倒数第二个字符中间的所有字符
    bcde
    >>> print(str * 2) # 输出两次str
    abcdefabcdef
    >>> print(str + 'ghigk') # 拼接
    abcdefghigk
    >>>

### 更新字符串 ###

python中的字符串是不可以改变的，你可以通过截取和拼接来生成另外一个字符串。  
比如：

>>> str = "helloWorld"
    >>> print (str[:5] + "China")
    helloChina

### 转义字符 ###

<table> 
 <thead> 
  <tr> 
   <th>转义字符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>(在行尾时)</td> 
   <td>续行符</td> 
  </tr> 
  <tr> 
   <td>\</td> 
   <td>反斜杠符号</td> 
  </tr> 
  <tr> 
   <td>’</td> 
   <td>单引号</td> 
  </tr> 
  <tr> 
   <td>"</td> 
   <td>双引号</td> 
  </tr> 
  <tr> 
   <td>\a</td> 
   <td>响铃</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>退格(Backspace)</td> 
  </tr> 
  <tr> 
   <td>\000</td> 
   <td>空</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>换行</td> 
  </tr> 
  <tr> 
   <td>\v</td> 
   <td>纵向制表符</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>横向制表符</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>换页</td> 
  </tr> 
  <tr> 
   <td>\oyy</td> 
   <td>八进制数，yy代表的字符，例如：\o12代表换行</td> 
  </tr> 
  <tr> 
   <td>\xyy</td> 
   <td>十六进制数，yy代表的字符，例如：\x0a代表换行</td> 
  </tr> 
  <tr> 
   <td>\other</td> 
   <td>其它的字符以普通格式输出</td> 
  </tr> 
 </tbody> 
</table>

### 字符串运算符 ###

*  `+` 拼接
 *  `*` 重复输出字符串
 *  `[]` 通过索引访问字符
 *  `[ : ]` 截取字符串中的一部分，左闭右开
 *  `in` 成员运算符，如果字符串中包含给定字符就返回True
 *  `not in` 成员运算符，如果字符串中不包含给定的字符就返回True
 *  `r` / `R` 原始字符串
 *  `%` 格式字符串

举例：

>>> str = "hello"
    >>> print (str[4] + "泡果奶") # 拼接
    o泡果奶
    >>> print ("h" in str)
    True
    >>> print ("a" not in str)
    True
    >>> print (str[0:2] + " is a bro")
    he is a bro
    >>> print (r"/n")
    /n

### 字符串格式化 ###

python支持格式化字符串的输出，可能会用到非常复杂的表达式，最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

举例：

>>> print ("姓名：%s 年龄：%s 性别：%s" % ('张三',19,'男'))
    姓名：张三 年龄：19 性别：男

另一种格式化字符串的方法是使用**format**()函数，基本语法是用`{}`和`:`代替了`%`  
format函数接收的参数不限，并且不要求顺序：

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
    'hello world'
     
    >>> "{0} {1}".format("hello", "world")  # 设置指定位置
    'hello world'

这部分内容有些杂，待写。

### Python三引号 ###

python三引号支持允许一个字符串跨多行，字符串中可以包含换行符，制表符以及其他特殊字符：

str = """when I was young
    
    I'd like to listen to the radio
    
    when then played 
    
    I'd sing along
    
    \t 作者：zzz 
    
    """
    
    print(str)

运行结果：

when I was young
    
    I'd like to listen to the radio
    
    when then played 
    
    I'd sing along
    
    	 作者：zzz

它遵循所见即所得的格式，一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。那么使用这种方式就免去了使用转义字符来确定格式。

### 字符串中的内置函数 ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>capitalize()</td> 
   <td>将字符串的第一个字符转换为大写</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>center(width, fillchar)</td> 
   <td>返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>count(str, beg= 0,end=len(string))</td> 
   <td>返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>bytes.decode(encoding=“utf-8”, errors=“strict”)</td> 
   <td>Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>encode(encoding=‘UTF-8’,errors=‘strict’)</td> 
   <td>以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>endswith(suffix, beg=0, end=len(string))</td> 
   <td>检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>expandtabs(tabsize=8)</td> 
   <td>把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>find(str, beg=0, end=len(string))</td> 
   <td>检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>index(str, beg=0, end=len(string))</td> 
   <td>跟find()方法一样，只不过如果str不在字符串中会报一个异常.</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>isalnum()</td> 
   <td>如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>isalpha()</td> 
   <td>如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>isdigit()</td> 
   <td>如果字符串只包含数字则返回 True 否则返回 False…</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>islower()</td> 
   <td>如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>isnumeric()</td> 
   <td>如果字符串中只包含数字字符，则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td>isspace()</td> 
   <td>如果字符串中只包含空白，则返回 True，否则返回 False.</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td>istitle()</td> 
   <td>如果字符串是标题化的(见 title())则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td>isupper()</td> 
   <td>如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td>join(seq)</td> 
   <td>以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串</td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td>len(string)</td> 
   <td>返回字符串长度</td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td>ljust(width[, fillchar])</td> 
   <td>返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。</td> 
  </tr> 
  <tr> 
   <td>21</td> 
   <td>lower()</td> 
   <td>转换字符串中所有大写字符为小写.</td> 
  </tr> 
  <tr> 
   <td>22</td> 
   <td>lstrip()</td> 
   <td>截掉字符串左边的空格或指定字符。</td> 
  </tr> 
  <tr> 
   <td>23</td> 
   <td>maketrans()</td> 
   <td>创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。</td> 
  </tr> 
  <tr> 
   <td>24</td> 
   <td>max(str)</td> 
   <td>返回字符串 str 中最大的字母。</td> 
  </tr> 
  <tr> 
   <td>25</td> 
   <td>min(str)</td> 
   <td>返回字符串 str 中最小的字母。</td> 
  </tr> 
  <tr> 
   <td>26</td> 
   <td>replace(old, new [, max])</td> 
   <td>把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。</td> 
  </tr> 
  <tr> 
   <td>27</td> 
   <td>rfind(str, beg=0,end=len(string))</td> 
   <td>类似于 find()函数，不过是从右边开始查找.</td> 
  </tr> 
  <tr> 
   <td>28</td> 
   <td>rindex( str, beg=0, end=len(string))</td> 
   <td>类似于 index()，不过是从右边开始.</td> 
  </tr> 
  <tr> 
   <td>29</td> 
   <td>rjust(width,[, fillchar])</td> 
   <td>返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串</td> 
  </tr> 
  <tr> 
   <td>30</td> 
   <td>rstrip()</td> 
   <td>删除字符串字符串末尾的空格.</td> 
  </tr> 
  <tr> 
   <td>31</td> 
   <td>split(str="", num=string.count(str))</td> 
   <td>num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串</td> 
  </tr> 
  <tr> 
   <td>32</td> 
   <td>splitlines([keepends])</td> 
   <td>按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。</td> 
  </tr> 
  <tr> 
   <td>33</td> 
   <td>startswith(substr, beg=0,end=len(string))</td> 
   <td>检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。</td> 
  </tr> 
  <tr> 
   <td>34</td> 
   <td>strip([chars])</td> 
   <td>在字符串上执行 lstrip()和 rstrip()</td> 
  </tr> 
  <tr> 
   <td>35</td> 
   <td>swapcase()</td> 
   <td>将字符串中大写转换为小写，小写转换为大写</td> 
  </tr> 
  <tr> 
   <td>36</td> 
   <td>title()</td> 
   <td>返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())</td> 
  </tr> 
  <tr> 
   <td>37</td> 
   <td>translate(table, deletechars="")</td> 
   <td>根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中</td> 
  </tr> 
  <tr> 
   <td>38</td> 
   <td>upper()</td> 
   <td>转换字符串中的小写字母为大写</td> 
  </tr> 
  <tr> 
   <td>39</td> 
   <td>zfill (width)</td> 
   <td>返回长度为 width 的字符串，原字符串右对齐，前面填充0</td> 
  </tr> 
  <tr> 
   <td>40</td> 
   <td>isdecimal()</td> 
   <td>检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。</td> 
  </tr> 
 </tbody> 
</table>

## List列表 ##

**List** 列表是Python中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。支持字符，数字，字符串甚至嵌套列表。

列表用`[ ]`标识，是python中最通用的复合数据类型。

列表可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list = ['hello',1000,'a']

### 访问列表中的值 ###

使用下标索引来访问列表中的值，同样可以使用方括号来截取列表。

列表中值的切割也可以用到变量 `[头下标:尾下标]`（含头不含尾）就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

此处与String类型相似。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MjM4MTQy_size_16_color_FFFFFF_t_70]

### 更新列表 ###

不同于字符串类型，列表是可以改变的，使用 `变量名[索引] = 值` 可以给列表中的元素重新赋值，或者你也可以通过**append**()方法来给列表添加元素。也可以使用**del**()函数或者**remove**()函数删除。

1.  重新赋值

list = ['a','b','c']
    list[0] = 'x'
    list[1] = 'y'
    list[2] = 'z'
    print(list)

运行结果：

['x', 'y', 'z']

1.  添加元素

list = ['a','b','c']
    list.append('d')
    print(list)

运行结果：

['a', 'b', 'c', 'd']

1.  删除元素

list = ['a','b','c']
    del list[0]
    print(list)

运行结果：

['b','c']

### 列表脚本操作符 ###

`+` 和 `*` 同样对列表有效。

*  号用于组合列表，\* 号用于重复列表。

### 列表的嵌套 ###

即在列表里面的元素是列表：

chars = ['a','b','c']
    nums = [1,2,3]
    lists = [chars,nums]
    print(lists)

运行结果：

[['a', 'b', 'c'], [1, 2, 3]]

### 列表函数及方法 ###

Python包含以下函数:

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>len(list)</td> 
   <td>列表元素个数</td> 
  </tr> 
  <tr> 
   <td>max(list)</td> 
   <td>返回列表元素最大值</td> 
  </tr> 
  <tr> 
   <td>min(list)</td> 
   <td>返回列表元素最小值</td> 
  </tr> 
  <tr> 
   <td>list(seq)</td> 
   <td>将元组转换为列表</td> 
  </tr> 
 </tbody> 
</table>

python包含以下方法:

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>list.append(obj)</td> 
   <td>在列表末尾添加新的对象</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>list.count(obj)</td> 
   <td>统计某个元素在列表中出现的次数</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>list.extend(seq)</td> 
   <td>在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>list.index(obj)</td> 
   <td>从列表中找出某个值第一个匹配项的索引位置</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>list.insert(index, obj)</td> 
   <td>将对象插入列表</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>list.pop([index=-1])</td> 
   <td>移除列表中的一个元素（默认最后一个元素），并且返回该元素的值</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>list.remove(obj)</td> 
   <td>移除列表中某个值的第一个匹配项</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>list.reverse()</td> 
   <td>反向列表中元素</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>list.sort( key=None, reverse=False)</td> 
   <td>对原列表进行排序</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>list.clear()</td> 
   <td>清空列表</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>list.copy()</td> 
   <td>复制列表</td> 
  </tr> 
 </tbody> 
</table>

## Tuple元组 ##

远组与列表相似，不同的是元组中的元素不能修改，而且元组使用的是小括号，而列表使用的是方括号。

1.  新建一个元组

tup1 = ("a","b","c");
    tup2 = (1,2,3);
    tup3 = 'A','B','C'; # 不适用括号也可以
    tub4 = () # 创建一个空元组

1.  当元组中只有一个元素时，需要在元素后面添加逗号，否则括号会被当做运算符使用：

>>>tup1 = (50)
    >>> type(tup1)     # 不加逗号，类型为整型
    <class 'int'>
     
    >>> tup1 = (50,)
    >>> type(tup1)     # 加上逗号，类型为元组
    <class 'tuple'>

1.  元组和字符串类似，下标索引从0开始，可以访问，截取，组合 。
2.  元组的元素值是不可以修改的，只能拼接组合。
3.  元组中的元素也是不能删除的，只能一次删除整个元组（使用del）
4.  `+` `*` 同样对元组有效
5.  元组内置函数

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>len(tuple)</td> 
   <td>计算元组中的元素个数</td> 
  </tr> 
  <tr> 
   <td>max(tuple)</td> 
   <td>返回元组中元素的最大值</td> 
  </tr> 
  <tr> 
   <td>min(tuple)</td> 
   <td>返回元组元素最小值</td> 
  </tr> 
  <tr> 
   <td>tuple(seq)</td> 
   <td>将列表转换为元组</td> 
  </tr> 
 </tbody> 
</table>

## Dictionary字典 ##

字典是另外一种可变容器模型，而且可以存储任意类型的对象。字典跟java中map很像，每一个元素都由键值对组成，每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号(\{\})中 ：

d = {
        key1 : value1 ,key2 : value2}

1.  键必须是唯一的，值没有要求
2.  值可以是任意数据类型，但是键必须是不可变的数据类型：Number String Tuple

### 访问字典中的值 ###

把相应的键放在方括号中就可以访问到它对应的值：

dict = {
        'Name': '张三', 'Age': 17, 'Class': '0601'}
    print (dict['Name'])
    print (dict['Age'])

### 更新字典 ###

1.  修改

dict = {
        'Name': '张三', 'Age': 17, 'Class': '0601'}
    dict['Age'] = 18

1.  新增

dict = {
        'Name': '张三', 'Age': 17, 'Class': '0601'}
    dict['Adress'] = '三里屯'

1.  删除

dict = {
        'Name': '张三', 'Age': 17, 'Class': '0601'}
     
    del dict['Name'] # 删除键 'Name'
    dict.clear()     # 清空字典
    del dict         # 删除字典

### 字典键的特性 ###

1.  不允许同一个键出现两次。创建时如果同一个键被赋值两次，前一个会被覆盖
2.  键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

### 字典内置函数&方法 ###

1.  内置函数

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>函数及描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>len(dict)</td> 
   <td>计算字典元素个数，即键的总数。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>str(dict)</td> 
   <td>输出字典，以可打印的字符串表示。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>type(variable)</td> 
   <td>返回输入的变量类型，如果变量是字典就返回字典类型。</td> 
  </tr> 
 </tbody> 
</table>

1.  内置方法

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>radiansdict.clear()</td> 
   <td>删除字典内所有元素</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>radiansdict.copy()</td> 
   <td>返回一个字典的浅复制</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>radiansdict.fromkeys()</td> 
   <td>创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>radiansdict.get(key, default=None)</td> 
   <td>返回指定键的值，如果值不在字典中返回default值</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>key in dict</td> 
   <td>如果键在字典dict里返回true，否则返回false</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>radiansdict.items()</td> 
   <td>以列表返回可遍历的(键, 值) 元组数组</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>radiansdict.keys()</td> 
   <td>返回一个迭代器，可以使用 list() 来转换为列表</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>radiansdict.setdefault(key, default=None)</td> 
   <td>和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>radiansdict.update(dict2)</td> 
   <td>把字典dict2的键/值对更新到dict里</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>radiansdict.values()</td> 
   <td>返回一个迭代器，可以使用 list() 来转换为列表</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>pop(key[,default])</td> 
   <td>删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>popitem()</td> 
   <td>随机返回并删除字典中的一对键和值(一般删除末尾对)。</td> 
  </tr> 
 </tbody> 
</table>

## Set集合 ##

集合（set）是一个无序的不重复元素序列。

可以使用大括号 \{ \} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 \{ \}，因为 \{ \} 是用来创建一个空字典。

创建格式：

parame = {
        value01,value02,...}
    # 或者
    set(value)

1.  添加元素 `set.add( x )`  
    将元素 x 添加到集合 set 中，如果元素已存在，则不进行任何操作。  
    另外一种添加元素的方法，参数可以是元素/列表/元组/字典`set.add( x , y , z ...)`
2.  删除元素`set.remove( x )`  
    将元素 x 从集合 s 中移除，如果元素不存在，报错。  
    还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误：`set.discatd(x)`  
    随机删除`set.pop()`在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）。
3.  计算集合中元素的个数`len(set)`
4.  清空集合`set.clear()`
5.  判断元素是否存在`x in set`
6.  方法整理：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>add()</td> 
   <td>为集合添加元素</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>移除集合中的所有元素</td> 
  </tr> 
  <tr> 
   <td>copy()</td> 
   <td>拷贝一个集合</td> 
  </tr> 
  <tr> 
   <td>difference()</td> 
   <td>返回多个集合的差集</td> 
  </tr> 
  <tr> 
   <td>difference_update()</td> 
   <td>移除集合中的元素，该元素在指定的集合也存在。</td> 
  </tr> 
  <tr> 
   <td>discard()</td> 
   <td>删除集合中指定的元素</td> 
  </tr> 
  <tr> 
   <td>intersection()</td> 
   <td>返回集合的交集</td> 
  </tr> 
  <tr> 
   <td>intersection_update()</td> 
   <td>删除集合中的元素，该元素在指定的集合中不存在。</td> 
  </tr> 
  <tr> 
   <td>isdisjoint()</td> 
   <td>判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>issubset()</td> 
   <td>判断指定集合是否为该方法参数集合的子集。</td> 
  </tr> 
  <tr> 
   <td>issuperset()</td> 
   <td>判断该方法的参数集合是否为指定集合的子集</td> 
  </tr> 
  <tr> 
   <td>pop()</td> 
   <td>随机移除元素</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>移除指定元素</td> 
  </tr> 
  <tr> 
   <td>symmetric_difference()</td> 
   <td>返回两个集合中不重复的元素集合。</td> 
  </tr> 
  <tr> 
   <td>symmetric_difference_update()</td> 
   <td>移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。</td> 
  </tr> 
  <tr> 
   <td>union()</td> 
   <td>返回两个集合的并集</td> 
  </tr> 
  <tr> 
   <td>update()</td> 
   <td>给集合添加元素</td> 
  </tr> 
 </tbody> 
</table>

[https_www.runoob.com_python3]: https://www.runoob.com/python3
[20190517131315121.png]: /images/20220131/91b3299b7efe493e883b3bc203200234.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MjM4MTQy_size_16_color_FFFFFF_t_70]: /images/20220131/01f95a4d7b67499f9182b72758f92943.png