## Bug的由来级分类

Bug一词的原意是“昆虫”或“虫子”;而在电脑系统或程序中隐藏着的一些未被发现的缺陷或问题,人们也叫它“bug”。

## 不同异常类型的处理方式

### 粗心导致的语法错误自查方法

- 漏掉了<font color=red>末尾的冒号</font>，如if语句，循环语句，else子句等
- <font color=red>缩进错误</font>，该缩进的没缩进，不该缩进的缩进了
- 把<font color=red>英文符号</font>写成中文符号，比如： **引号** , **冒号**, **括号** 
- 字符串拼接的时候，把<font color=red>字符串和数字</font>拼在一起
- 没有定义变量，比如while的循环条件的变量
- <font color=red>"=="</font>比较运算符和<font color=red>"="</font>赋值运算符用错了



```python
age=input('请输入你的年龄')
print(type(age))
# if age >= 18 # 默认"input()"输入的类型都是str类型，需要转换int类型比较，还有结尾忘记写“:"了。
if int(age) >= 18:
    print('你已经是成年人了')

i=0
while i < 10:
    print(i)
    i+=1  # 如果忘记改变i的变量，i就会一直是0，会陷入死循环
```



### 知识不熟练导致的错误

知识不熟练导致的错误，就需要多加练习了

```python
lst=[11,22,33,44]
# print(lst[4]) # 索引超出范围，列表的索引从0开始的，想输出第4个元素，索引应该填写3
print(lst[3])

lst=[]
# lst=append('A','B','C') # append()方法掌握不熟练，append一次只能添加一个元素，是lst的方法，不应该使用赋值运算符
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)
```



### 思路不清晰导致的错误

思路不清晰导致的错误可以使用`print()`函数打印输出，使用`#`暂时注释掉部分代码。

题目要求：使用列表存储电影信息，要求输入名字显示xxx出演了哪部电影。

```python
lst=[{'rating':[9.7,2062397],'id':'1292052','type':['犯罪','剧情'],'title':'肖申克的救赎','actors':['蒂姆·罗宾斯','摩根·费里曼']},
     {'rating':[9.6,1528760],'id':'1291546','type':['剧情','爱情','同性'],'title':'霸王别姬','actors':['张国荣','张丰毅','冯巩','葛优']},
     {'rating':[9.5,155919],'id':'1292720','type':['爱情','剧情'],'title':'阿甘正传','actors':['汤姆·汉克斯','罗宾·怀特']}
     ]
'''思路不清晰的错误示例
name=input('请输入你要查询的演员名字：')
for item in lst: # 遍历列表
    for movie in item:
        print(movie)
        actors=movie['actors']
        if name in actors:
            print(name+'出演了'+actors)'''

# 正确的思路代码
name=input('请输入你要查询的演员名字：')
for item in lst:
    act_lst=item['actors']
    if name in act_lst:
        print(name+'出演了'+item['title'])
```



### 被动掉坑导致的错误

程序代码逻辑没有错，因为用户错误操作或一些”例外情况“而导致的程序崩溃。

题目要求：输入2个整数并运行除法运算

```python
a=int(input('请输入第一个整数'))
b=int(input('请输入第二个整数'))
result=a/b
print('结果为',result)

请输入第一个整数20
请输入第二个整数0 # 0是不能作为除数的，所以会报错
Traceback (most recent call last):
  File "D:\work\code\python\main.py", line 3, in <module>
    result=a/b
ZeroDivisionError: division by zero
```



## 异常处理机制

python提供了异常处理机制，可以在异常出现时即使捕获，让程序继续运行。

```python
try:
    a=int(input('请输入第一个整数'))
    b=int(input('请输入第二个整数'))
    result=a/b
    print('结果为',result)
except ZeroDivisionError: # 如果是ZeroDivisionError错误，会执行下面的代码
    print('对不起，除数不允许为0')
except ValueError: # except的多分枝
    print('对不起，只能输入数字串')
print('程序结束')
```

多个except结构，捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加**BaseException**。

```python
try:
    a=int(input('请输入第一个整数'))
    b=int(input('请输入第二个整数'))
    result=a/b
    print('结果为',result)
except BaseException as e: # 如果抛出异常执行except块
    print('出错了',e)
else: # try块中没有抛出异常执行else
    print('计算结果为',result)
finally: # 不论程序有没有抛出异常，都会执行finally
    print('谢谢您的使用')
```

python常见的异常类型

| 序号 | 异常类型          | 描述                        |
| ---- | ----------------- | --------------------------- |
| 1    | ZeroDivisionError | 除(或取模)零(所有数据类型)  |
| 2    | IndexError        | 序列中没有此索引(index)     |
| 3    | KeyError          | 映射中没有这个key           |
| 4    | NameError         | 未声明/初始化对象(没有属性) |
| 5    | SyntaxError       | Python语法错误              |
| 6    | ValueError        | 传入无效的参数              |

```python
# print(10/0) # ZeroDivisionError
lst=[11,22,33,44]
# print(lst[4]) # IndexError 索引从0开始，超出索引范围
dic={'name':'张三','age':20}
# print(dic['gender']) # KeyError key不存在
# print(num) # NameError
# int a=20 # SyntaxError
# a=int('hello') # ValueError
```

使用traceback模块打印异常信，可以把打印的异常信息存入到日志文件里。

```python
import traceback
try:
    print('---------')
    print(1/0)
except:
    traceback.print_exc()
```



## Pycharm的调试模式

断点：程序运行到此处，暂时挂起，停止执行，此时可以详细观察程序的运行情况，方便做出进一步的判断

进入调试视图三种方式

-  单机工具栏上的这个按钮 ![](https://blog.lm950.top/static/img/2a958ef8bbd0efc2cf33ca433a7723e1.image.webp)
- 右键单击编辑区点击：`debug'模块名'`
- 按快捷键： `shift+F9`

python入门到精通第十一章

## 函数的创建和参数传递

函数就是完成特定功能的一段代码，可以调用函数复用代码，提高可维护性，使用 `def` 定义。

```python
def calc(a,b): # a,b成为形式参数（形参），参数的位置是在函数的定义处
    c=a+b
    return c
result=calc(10,20) # 位置传参，按照顺序传参，10,20成为实际参数的值（实参），参数的位置是函数的调用处
print(result)

res=calc(b=10,a=20) # =左侧变量的名称称为关键字参数，根据形参的名称进行传参
print(res)
```



函数调用过程中，如果传递参数是不可变对象，在函数体的修改不会影响实参的值，如果是可变对象，在函数体的修改会影响实际参数的值。

```python
def fun(arg1,arg2):
    print('arg1=',arg1)
    print('arg2=',arg2)
    arg1=100
    arg2.append(10)
    print('arg1=',arg1)
    print('arg2=',arg2)

n1=11
n2=[22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2) # 位置传参，形参名称和实参名称可以不一致
print('n1',n1) # 如果是不可变对象，在函数体的修改不会影响实参的值
print('n2',n2) # 函数体执行完后append(10)，会影响到n2的值
```



## 函数的返回值

函数执行完毕后，不需要给调用处提供数据，return可以省略不写，如果返回值是1个，直接返回原类型，如果是多个返回值，返回的结果为元组。

```python
def fun(num):
    odd=[] # 存奇数
    even=[] # 存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
lst=[10,32,35,66,93,55,97,98]
print(fun(lst))

def fun1(): # 第一种定义函数方式，不需要返回数据
    print('hello')
fun1()

def fun2(): # 第二种定义方式，返回一个值，返回的类型是原类型
    return 'hello'
fun2()
print(fun2())

def fun3(): # 第三种定义方式，返回多个值，返回的是元组
    return 'hello','python'
print(fun3())
```



## 函数的参数定义

- 函数定义时，给形参设置默认值，只有与默认值不符的时候，才需要传递实参

  ```python
  def fun(a,b=10): # 定义函数，10是b参数的默认值
      print(a,b)
  fun(100) # 只传一个参数赋值给a，b参数使用默认值
  fun(20,30) # 传递2个参数，30会替换掉10的默认值
  
  print('hello',end='\t') # print默认值是end='\n'，把end改为\t，替换掉默认值就不会换行了
  print('world')
  ```

- 函数定义时，无法事先确定传递参数位置实参的个数，使用可变的位置参数，使用 **\*** 定义个数可变的位置形参，结果为一个元组

  ```python
  def fun(*args): # 可变的位置参数，可以传递多个参数
      print(args)
  fun(10)
  fun(20,30)
  ```

- 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变关键字形参，使用 **\*\* ** 定义个数可变的关键字形参，结果为一个字典。

  ```python
  def fun1(**args): # 可变的关键字参数，返回的是字典
      print(args)
  fun1(a=10)
  fun1(a=20,b=30,c=40)
  ```

- 个数可变的位置参数和个数可变的关键字参数都只能是填写一个，如果定义函数既有个数可变的关键字形参，也有个数可变的位置形参，要求个数可变的位置形参放在个数可变的关键字形参之前。

  ```python
  def fun2(*args1,**args2):
      print(args1,args2)
  fun2(10,30,a=25,b=23)
  ```



## 函数的定义与调用

| 参数的类型                             | 函数的定义 | 函数的调用 | 备注     |
| -------------------------------------- | ---------- | ---------- | -------- |
| 位置实参                               |            | &#10004;   |          |
| 将列表中的每个元素都转为位置实参       |            | &#10004;   | 使用\*   |
| 关键字实参                             |            | &#10004;   |          |
| 将字典中的每个键值对都转换为关键字实参 |            | &#10004;   | 使用\*\* |
| 默认值形参                             | &#10004;   |            |          |
| 关键字形参                             | &#10004;   |            | 使用\*   |
| 个数可变的位置形参                     | &#10004;   |            | 使用\*   |
| 个数可变的关键字形参                   | &#10004;   |            | 使用\*\* |

函数调用时的参数传递：

```python
def fun(a,b,c): # 定义一个形式参数
    print('a',a)
    print('b',b)
    print('c',c)
fun(10,20,30)
lst=[11,22,33]
fun(*lst) # 在函数调用时，将列表中的每个元素都转换为位置实参传入，列表名前需要加*

dic={'a':100,'b':200,'c':300}
fun(**dic) # 将字典中的键值对都转换成关键字实参传入，字典名前需要加**
```

函数定义的形参：

```pyt
def fun(a,b=10):
    print('a=',a)
    print('b=',b)

def fun2(*args): # 个数可变的位置形参
    print(args)
def fun3(**args): # 个数可变的关键字形参
    print(args)
fun2(10,20,30,40) # 结果是元组
fun3(a=11,b=22,c=33,d=44) # 结果返回字典

def fun4(a,b,*,c,d): # 从*之后的参数，在函数调用时，只能采用关键字参数传参
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
fun4(10,20,c=30,d=40) # 前两个参数是采用位置实参传递，而c,d采用关键字实参传递

# 以下方式都可以定义函数
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args2):
    pass
def fun7(a,b=10,*args,**args2):
    pass
```



## 变量的作用域

程序代码能访问该变量的区域，可分为 **局部变量** 和 **全局变量** ，在函数内定义并使用的变量，只能在函数内部有效，局部变量使用global声明，这个变量就会成为全局变量，在函数体外定义的变量，可作用域函数内外，就是全局变量

```python
def fun(a,b):
    c=a+b # c就是局部变量，因为c在函数体内定义的变量，a,b是形参，也是局部变量，属于函数体内部变量
    print(c)

name='leo' # 这个name变量，函数内部和外部都可以使用，所以这个是全局变量
print(name)
def fun2():
    print(name)
fun2()

def fun3():
    global age # age是函数内部变量，局部变量，局部变量使用global声明后，这个便俩个就会变成全局变量
    age=23
    print(age)
fun3()
print(age) # 在函数体内的age变量使用global声明后，可以在函数外部使用了
```



## 递归函数

如果在一个函数的函数体内调用了该函数本身，这个函数就成为 **递归函数** ，递归调用需要有一个终止条件，每递归调用一次函数，都会在栈内存分配一个栈帧，每执行完一次函数，都会释放相应的空间。

```python
def fac(n):
    if n == 1:
        return 1
    else:
        return n*fac(n-1) # 使用递归计算阶乘
print(fac(6))

def fib(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
print(fib(6)) # 打印斐波那契数列的第6位数
for i in range(1,7): # 输出前6位数字
    print(fib(i))
```

python入门到精通第十章

## 字符串的驻留机制

字符串是基本数据类型，是一个不可变序列，python的驻留机制，不同的值被存到字符串的驻留池中，创建相同字符串的变量时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量

```python
a='python'
b="python"
c='''python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))
```

在交互模式下的驻留机制



- 字符串长度为 **0** 或者 **1** 时

  ```python
  >>> s1='' # 字符串长度为0
  >>> s2=''
  >>> s1 is s2
  True
  >>> s1='%' # 字符串长度为1
  >>> s2='%'
  >>> s1 is s2
  True
  >>> s1='abc%'
  >>> s2='abc%'
  >>> s1 == s2
  True
  >>> s1 is s2
  False
  >>> id(s1)
  2196612824048
  >>> id(s2)
  2196612823984
  ```

- 符合标识符的字符串(字母，数字，下划线)

  ```python
  >>> s1='abcd123_'
  >>> s2='abcd123_'
  >>> s1 is s2
  True
  >>> id(s1)
  2196612824176
  >>> id(s2)
  2196612824176
  ```

- 字符串只在编译时进行驻留，而非运行时

  ```python
  >>> a='abc'
  >>> b='ab'+'c' # 程序运行之前就赋值好了
  >>> c=''.join(['ab','c']) # 这个是程序运行时才赋值的
  >>> a is b
  True
  >>> a is c
  False
  >>> c
  'abc'
  >>> type(c)
  <class 'str'>
  >>> a
  'abc'
  >>> type(a)
  <class 'str'>
  ```

- [-5,256]之间的整数数字

  ```python
  >>> a=-5
  >>> b=-5
  >>> a is b
  True
  >>> a=-6
  >>> b=-6
  >>> a is b
  False
  >>> import sys
  >>> a='abc%'
  >>> b='abc%'
  >>> a is b
  False
  >>> a=sys.intern(b) # 强制驻留
  >>> a is b
  True
  ```

在需要进行字符串拼接时建议使用str类型的 `join` 方法，因为 `join()` 方法是先计算出所有字符串中的长度，然后再拷贝，只创建一次对象，效率比 `+` 效率高



## 字符串的常用操作

- 字符串的查询操作

  <table>
      <tr>
          <td>功能</td>
          <td>方法名称</td>
          <td>作用</td>
      </tr>
  	<tr>
          <td rowspan="5">查询方法</td>
      </tr>
  	<tr>
          <td>index()</td>
          <td>查找子串substr第一次出现的位置，如果查找的子串不存在，会抛出异常ValueError</td>
      </tr>
      <tr>
          <td>rindex()</td>
          <td>查找子串substr最后一次出现的位置，如果查找的子串不存在，会抛出异常ValueError</td>
      </tr>
      <tr>
          <td>find()</td>
          <td>查找子串substr第一次出现的位置，如果查找的子串不存在，则返回-1</td>
      </tr>
      <tr>
          <td>rfind()</td>
          <td>查找子串substr最后一次出现的位置，如果查找的子串不存在，则返回-1</td>
      </tr>
  </table>


  ```python
  s='hello,hello'
  print(s.index('lo'))
  print(s.find('lo'))
  print(s.rindex('lo'))
  print(s.rfind('lo'))
  # print(s.index('a')) # ValueError: substring not found 查找不存在的子串会抛异常
  print(s.find('a')) # -1 查找不存在的子串返回-1
  ```

- 字符串的大小写转换

  <table>
      <tr>
          <td>功能</td>
          <td>方法名称</td>
          <td>作用</td>
      </tr>
  	<tr>
          <td rowspan="6">大小写转换</td>
      </tr>
  	<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>
  </table>


  ```python
  s='hello,python'
  a=s.upper() # 转换成大写后会产生新的字符串对象
  print(a,id(a))
  print(s,id(s))
  
  b=s.lower() # 原来是小写，转成成小写后也会新建字符串对象
  print(b,id(b))
  print(s,id(s))
  
  s2='hello,Python'
  print(s2.swapcase()) # 大写变小写，小写变大写
  
  print(s2.title()) # 每个单词的第一个字符串大写，其余小写
  ```

- 字符串内容对其的操作方法

  <table>
      <tr>
          <td>功能</td>
          <td>方法名称</td>
          <td>作用</td>
      </tr>
  	<tr>
          <td rowspan="5">字符串对齐</td>
      </tr>
  	<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>
  </table>


  ```python
  s='hello,Python'
  print(s.center(20,'*')) # 居中对齐
  
  print(s.ljust(20,'*')) # 左对齐
  print(s.ljust(20)) # 左对齐，默认填充空格
  print(s.ljust(10)) # 指定宽度小于原字符串，返回原字符串
  
  print(s.rjust(20,'*')) # 右对齐
  print(s.rjust(20))
  print(s.rjust(10))
  
  print(s.zfill(20)) # 右对齐，默认填充0
  print(s.zfill(10))
  print('-9835'.zfill(8)) # 如果字符串以“+”或“-”开头，则在符号之后填充
  ```

- 字符串劈分操作

  <table>
      <tr>
          <td>功能</td>
          <td>方法名称</td>
          <td>作用</td>
      </tr>
  	<tr>
          <td rowspan="9">字符串的劈分</td>
      </tr>
  	<tr>
          <td rowspan="4">split()</td>
      </tr>
  	<tr>
          <td>从字符串的左边开始劈分，默认的劈分字符串是空格字符串，返回的值都是一个列表</td>
  	</tr>
  	<tr>
          <td>以通过参数sep指定劈分字符串是劈分符</td>
  	</tr>
  	<tr>
          <td>通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分</td>
      </tr>
      <tr>
          <td  rowspan="4">rsplit()</td>
      </tr>
  	<tr>
          <td>从字符串的右边开始劈分，默认的劈分字符串是空格字符串，返回的值都是一个列表</td>
  	</tr>
  	<tr>
          <td>以通过参数sep指定劈分字符串是劈分符</td>
  	</tr>
  	<tr>
          <td>通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分</td>
      </tr>
  </table>


  ```python
  s='hello world python'
  lst=s.split() # 默认空格分隔符
  print(lst)
  
  s1='hello:world:python'
  print(s1.split(sep=':')) # 指定以”：“分隔
  print(s1.split(sep=':',maxsplit=1)) # 指定最大分隔次数
  
  print(s1.rsplit(':')) # 没有指定最大分隔次数，rsplit和split是一样的
  print(s1.rsplit(':',maxsplit=1)) # 从右侧开始分隔，设置了最大分隔次数
  ```

- 判断字符串操作

  <table>
      <tr>
          <td>功能</td>
          <td>方法名称</td>
          <td>作用</td>
      </tr>
  	<tr>
          <td rowspan="7">判断字符串的方法</td>
      </tr>
  	<tr>
          <td>isidentifier()</td>
          <td>判断指定的字符串是不是合法的标识符</td>
      </tr>
      <tr>
          <td>isspace()</td>
          <td>判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符等）</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>
  </table>

  ```python
  s='hello，python'
  print('1.',s.isidentifier()) # 判断是否是合法字符串
  print('2.','hello123_张三'.isidentifier()) # True
  
  print('3.','\t'.isspace()) # 判断是否是空白字符
  
  print('4.','abc'.isalpha()) # 判断是否全部由字母组成
  print('5.','张三'.isalpha()) # True
  print('6.','张三1'.isalpha()) # False
  
  print('7.','1234'.isdecimal()) # 判断字符串是否由十进制数字组成
  print('8.','123四'.isdecimal()) # False
  print('9.','ⅠⅡⅢ'.isdecimal()) # False
  
  print('10.','123'.isnumeric()) # 判断指定字符串是否由数字组成
  print('11.','123四'.isnumeric()) # True
  print('12.','ⅠⅡⅢ'.isnumeric()) # True
  
  print('13.','abc'.isalnum()) # 判断字符串是否全部由字母和数字组成
  print('14.','张三123abc'.isalnum()) # True
  print('15.','abc!'.isalnum()) # False
  ```

- 字符串操作的其他方法

  <table>
      <tr>
          <td>功能</td>
          <td>方法名称</td>
          <td>作用</td>
      </tr>
  	<tr>
          <td>字符串替换</td>
          <td>repace()</td>
          <td>第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第三个参数指定最大替换次数</td>
      </tr>
  	<tr>
          <td>字符串的合并</td>
          <td>join()</td>
          <td>将列表或元组中的字符串合并成一个字符串</td>
      </tr>
  </table>

  ```python
  s='hello，python'
  print(s.replace('python','java')) # 把python字符串替换成java
  s1='hello,python,python,python'
  print(s1.replace('python','java',2)) # 设置替换最大次数
  
  lst=['hello','world','python']
  print('|'.join(lst)) # 把字符串用“|”连接
  t=('hello','world','python')
  print(''.join(t)) # 把元组内的字符串合并一个字符串
  print('*'.join('python')) # 把字符串使用”*“连接起来
  ```



## 字符串的比较

**运算符** ： `>` ,`>=` , `<` , `<=` , `=` , `==` , `!=` ， `==` 比较的是 **value** ， `is` 比较的是 **id** 是否相等。

**比较规则** ：首先比较2个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较。

**比较原理** ：两个字符串比较时，比较的是其 `ordinal value` (原始值)，调用内置函数 `ord` 可以得到指定字符串的 `ordinal value` 。调用内置函数 `chr` 时指定 `ordinal value` 可以得到其对应的字符。

```python
print('apple'>'app') # True
print('apple'>'banana') # False 第一个字母比较相当于97>98，所以为False
print(ord('a'),ord('b')) # 获得字母的原始值
print(chr(97),chr(98)) # 使用原始值获取字符

a=b='python'
c='python'
print(a==b) # True
print(a==c) # True
print(a is b) # True
print(a is c) # True
print(id(b)) # 1838709970608
print(id(c)) # 1838709970608
```



## 字符串的切片操作

字符串是不可变类型，切片后会产生新的对象，语法 ` [start:end:step]` 第一个参数 **开始** ，第二个参数 **结束** ，第三个参数为 **步长** 

```python
s='hello,python'
s1=s[:5] # 没有指定起始位置，默认从索引0开始切
s2=s[6:] # 没有指定结束位置，默认会切片到最后一个元素
print(s,id(s)) # 切片操作会产生新的对象
print(s1,id(s1))
print(s2,id(s2))

print(s[1:5:1]) # 从索引1开始截到索引5（不包含索引5的位置），步长为1
print(s[::2]) # 默认从0开始，默认截到最后一个元素，步长为2
print(s[::-1]) # 步长为负数，默认从最后一个元素开始
print(s[-6::1]) # 从-6索引开始，到最后一个元素结束，步长为1
```



## 格式化字符串

格式化字符串就是按照一定的格式输出字符串，可以使用 `%` 、 `{}` 和 `str.format()` 来格式化字符串，示例如下：

```python
name='张三'
age=48
print('我叫%s，今年%d岁了' % (name,age)) # 使用"%"作为占位符
print('我叫{0}，今年{1}岁了'.format(name,age)) # 调用format()方法，使用“{}”作为占位符
print(f'我叫{name},今年{age}岁了') # 使用f也可以格式化字符串

print('%10d' % 87) # 10表示的是宽度
print('%.2f' % 3.1415926) # %f表示浮点数.2表示保留小数点后2位
print('%10.2f' % 3.1415926) # 同时表示宽度和精度，总宽度为10，小数点后2为

print('{0:.2}'.format(3.1415926)) # 0表示的是占位符的顺序（可以省略），.2表示一共2位数
print('{0:.2f}'.format(3.1415926)) # .2f表示2为小数
print('{0:10.2f}'.format(3.1415926)) # 总宽度为10，保留2为小数
```

| 数字       | 格式                                                         | 输出                   | 描述                         |
| :--------- | :----------------------------------------------------------- | :--------------------- | :--------------------------- |
| 3.1415926  | {:.2f}                                                       | 3.14                   | 保留小数点后两位             |
| 3.1415926  | {:+.2f}                                                      | +3.14                  | 带符号保留小数点后两位       |
| -1         | {:-.2f}                                                      | -1.00                  | 带符号保留小数点后两位       |
| 2.71828    | {:.0f}                                                       | 3                      | 不带小数                     |
| 5          | {:0>2d}                                                      | 05                     | 数字补零 (填充左边, 宽度为2) |
| 5          | {:x<4d}                                                      | 5xxx                   | 数字补x (填充右边, 宽度为4)  |
| 10         | {:x<4d}                                                      | 10xx                   | 数字补x (填充右边, 宽度为4)  |
| 1000000    | {:,}                                                         | 1,000,000              | 以逗号分隔的数字格式         |
| 0.25       | {:.2%}                                                       | 25.00%                 | 百分比格式                   |
| 1000000000 | {:.2e}                                                       | 1.00e+09               | 指数记法                     |
| 13         | {:>10d}                                                      | 13                     | 右对齐 (默认, 宽度为10)      |
| 13         | {:<10d}                                                      | 13                     | 左对齐 (宽度为10)            |
| 13         | {:^10d}                                                      | 13                     | 中间对齐 (宽度为10)          |
| 11         | `'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)` | `1011 11 13 b 0xb 0XB` | 进制                         |

**^**, **<**, **>** 分别是居中、左对齐、右对齐，后面带宽度， **:** 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

**+** 表示在正数前显示 **+**，负数前显示 **-**； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。



## 字符串的编码转换

计算机在网络传输的时候，需要将数据转换成 **byte** 字节传输，编码是为了存储传输，解码是为了方便显示阅读

- **编码**：将字符串转换为二进制数据(bytes)
- **解码**：将bytes类型的数据转换成字符串类型

```python
s='我是字符串'
# 编码
print(s.encode(encoding='GBK')) # 在GBK编码中，一个中文占2个字节
print(s.encode(encoding='UTF-8')) # 在UTF-8编码格式中，一个中文占用3个字节

# 解码
byte=s.encode(encoding='GBK') # 把byte编码后的结果赋值给byte
print(byte.decode(encoding='GBK'))
byte1=s.encode(encoding='UTF-8')
print(byte1.decode(encoding='UTF-8')) # 解码UTF-8
```

python入门到精通第九章

## 什么是元组

元组是python内置的数据结构之一，是一个不可变序列

- 不可变序列： **字符串** 、 **元组** ，不可变序列没有增、删、改操作

  ```python
  s="hello"
  print(s,id(s)) # hello 2310315349424
  s=s+"python"
  print(s,id(s)) # hellopython 2310315349936
  ```

- 可变序列： **列表** 、 **字典** ，可以对序列进行增、删、改操作，对象的地址不会改变

  ```python
  lst=[20,50,32]
  print(lst,id(lst)) # [20, 50, 32] 2310314979712
  lst.append(84)
  print(lst,id(lst)) # [20, 50, 32, 84] 2310314979712
  ```



## 元组的创建方式

使用 `()` 和内置函数 `tuple()` 创建元组，只包含一个元组的元素需要使用逗号和小括号

```python
t=('python','world',65) # 使用小括号创建元组
print(t,type(t))

t2='python','world',65 # 可以把小括号省略
print(t2,type(t2))
t3=('python',) # 只有一个元组需要在元素后面加上逗号
print(t3,type(t3))

t1=tuple(('python','world',65)) # 内置函数tuple()创建元组
print(t1,type(t1))
```

元组中存储的是对象的引用，元组中的对象是不可变对象，不能再引用其他对象，如果元组中的对象是可变对象，可变对象的引用不允许修改，但是数据可以改变

```python
t=(10,[20,30],15)
print(t,type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
t[1].append(89) # [20,30]是列表，列表是可以变对象，可以修改列表的数据，在列表中添加元素
print(t,id(t[1])) # t[1]的列表地址不变
```



## 元组的遍历

元组是可迭代对象，可以使用 `for x in (1,2,3)` 遍历。

```python
t=('python','world',65)
for item in t:
    print(item)
```



## 集合的创建

集合是python的内置数据结构，是属于可变类型的序列，集合没有value的字典。集合创建方式如下：

```python
s={1,2,3,3,4,5,5} # 集合的元素不允许重复，重复的元素会自动去掉
print(s)

s1=set(range(6)) # 第二种创建方式
print(s1,type(s1))

s2=set([2,3,3,5,6,6]) # 可以把列表中的元素转成集合的元素
print(s2,type(s2))

s3=set((3,2,90,35,23))
print(s3,type(s3))

s4=set('python')
print(s4,type(s4))

s5=set({23,56,31,94,98})
print(s5,type(s5))

s6=set() # 定义空集合
print(s6,type(s6))
```



## 集合的增、删、改、查操作

- 判断集合中是否存在指定的元素

  ```python
  s={10,52,73,6,85,35}
  print(10 in s) # True
  print(100 in s) # False
  print(10 not in s) # False
  print(100 not in s) # True
  ```

- 集合的新增操作

  ```python
  s={10,52,73,6,85,35}
  s.add(152) # 一次添加一个元素
  s.update({100,200,300}) # update 一次至少可以添加一个元素
  s.update([39,94,58])
  s.update((58,97))
  print(s)
  ```

- 集合的删除操作

  ```python
  s={10,52,73,100,85,35}
  s.remove(100) # 删除一个指定的元素，如果元素不存在会报错
  print(s)
  s.discard(500) # 如果删除一个不存在的元素，不会报错
  print(s)
  s.pop() # 随机任意一个元素，这个pop()方法不能添加参数
  print(s)
  s.clear() # 清空元素
  print(s)
  ```

- 集合之间的关系

  ```python
  s={10,20,30,40,50,60}
  s1={10,20,30,40,50,60}
  s2={10,20,30,40}
  s3={10,20,70}
  print(s==s1) # True 判断集合是否相等（元素相同就相等）
  print(s!=s1) # False
  print(s2.issubset(s1)) # True 判断s2是不是s1的子集
  print(s3.issubset(s1)) # False
  print(s1.issuperset(s2)) # True 判断s1是不是s2的超集
  print(s1.issuperset(s3)) # False
  print(s2.isdisjoint(s3)) # 判断元素是否没有交集，没有交集为True
  ```

- 集合的交集操作

  ```python
  s1={10,20,30,40}
  s2={20,30,40,50,60}
  print(s1.intersection(s2))
  print(s1 & s2) # intersection()与 & 是一样的效果，交集操作
  ```

- 集合的并集操作

  ```python
  s1={10,20,30,40}
  s2={20,30,40,50,60}
  print(s1.union(s2))
  print(s1 | s2) # union() 与 | 等价
  ```

- 集合的差集操作

  ```python
  s1={10,20,30,40}
  s2={20,30,40,50,60}
  print(s1.difference(s2))
  print(s1 - s2) # difference() 与 - 等价
  ```

- 集合的对称差集操作

  ```python
  s1={10,20,30,40}
  s2={20,30,40,50,60}
  print(s1.symmetric_difference(s2))
  print(s1 ^ s2) # symmetric_difference() 与 ^ 等价
  ```



## 集合推导式

集合生成式

```python
s={i*i for i in range(6)}
print(s)
```



| 数据结构    | 是否可变 | 是否重复                     | 是否有序 | 定义符号    |
| ----------- | -------- | ---------------------------- | -------- | :-----------: |
| 列表(list)  | 可变     | 可重复                       | 有序     | []          |
| 元组(tuple) | 不可变   | 可重复                       | 有序     | ()          |
| 字典(dict)  | 可变     | key不可重复<br />value可重复 | 无序     | {key\:value} |
| 集合(set)   | 可变     | 不可重复                     | 无序     | {}          |

python入门到精通第八章

## 什么是字典

字典与列表一样是一个可变序列(可以做增删改操作)，存储的值可以是任何数据类型，但键必须是不可变序列，以键值对的方式存储数据，字典的每个键值 **key:value** 对用冒号 **:** 分割，每个键值对之间用逗号 **,** 分割，整个字典包括在花括号 **{}** 中 ,格式如下所示：

```python
a={"ke1":"vale1","ky2":"vale2"}
```



## 字典的创建

字典的常用的创建方式是使用 `{}` 花括号创建，也可以使用内置函数 `dict()` 创建。

```python
a={"姓名":"张三","年龄":28} # 第一种创建方式
print(a,type(a)) # 类型为 dict

b=dict(name="allen",age=19) # 第二种创建字典方式
print(b,type(b))

c={} # 空字典
```



## 字典的查询操作

获取字典中的元素可以使用 `[]` 和 `get()` 获取，区别在于如果使用 `[]` 查找一个不存在键会报错，而使用 `get()` 查找不存在键，会返回 **None** 。

```python
scores={"张三":98,"李四":86}
print(scores["张三"]) # 第一种获取方式
# print(scores["王五"]) # KeyError: '王五' 会报错

print(scores.get("李四")) # 第二种获取方式
print(scores.get("王五")) # 查找不存在的键返回None，不会报错
print(scores.get("王五",87)) # 87是查找“张三”的键不存在时，返回的默认值
```



## 字典元素的增、删、改操作

- 字典的 **判断、增、删、改** 操作

  ```python
  scores={"张三":76,"李四":86,"王五":93}
  print("张三" in scores) # 判断"张三"在字典里是否存在
  print("张三" not in scores)
  
  del scores["张三"] # 删除指定的键值对
  print(scores)
  
  scores.clear() # 清空字典
  print(scores)
  
  scores["赵六"]=69 # 新增键值对
  print(scores)
  
  scores["赵六"]=99 # 修改指定的键的值
  print(scores)
  ```

- 字典的视图操作

  ```python
  scores={"张三":76,"李四":86,"王五":93}
  keys=scores.keys() # 获取所有的key
  print(keys,type(keys)) # 类型"dict_keys"
  print(list(keys)) # 可以转换成列表
  
  values=scores.values() # 获取所有的values
  print(values,type(values)) # 类型为"dict_values"
  print(list(values))
  
  items=scores.items() # 获取所有的key-value对
  print(items,type(items)) # 类型"dict_items"
  ```

- 字典元素的遍历

  ```python
  scores={"张三":76,"李四":86,"王五":93}
  for item in scores:
      print(item,scores[item])
  ```



## 字典推导式

使用内置函数 `zip()` ，语法是 `<dict_name> = {<new_key>:<new_value> for <item> in <iterable>}` 

```python
items=['Fruits','Books','Others']
prices=[88,93,75]

d={item.upper():price for item,price in zip(items,prices)}
print(d)
```