基础知识

在Python中，一共有5种基本的数据类型
Numbers（数字），String（字符串），List（列表），Tuple（元组），Dictionary（字典）

定义字符串的三种方式

  • 使用单引号
  • 使用双引号
  • 使用三引号
    • 如果三引号包裹的数据被一个变量所接收，那么对应的就是一个字符串
    • 如果包裹的数据没有被变量所接收，那么对应的就是多行注释 ```python a = “””hello”””

“”” hello,world “””

print(f”the value of a is: {a}”)

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/21436600/1662039005486-01546a97-8431-4d29-9396-089d2f805d6b.png#clientId=ucd76dc74-fe48-4&from=paste&height=218&id=u4eea7f56&originHeight=272&originWidth=677&originalType=binary&ratio=1&rotation=0&showTitle=false&size=18565&status=done&style=none&taskId=u55112e2a-6218-4057-af7b-29ef956751c&title=&width=541.6)
  2. <a name="DArmI"></a>
  3. ## 缩进
  4. 在Python的语法中，不再使用大括号来限定语句块，而是通过代码的缩进来判断语句所属哪一个逻辑层次。因此，在Python中，合适、合法的代码缩进是很重要的
  5. <a name="iJJYV"></a>
  6. ## 字符串格式化
  7. <a name="r7GAe"></a>
  8. # 基础语法
  9. <a name="NqLaq"></a>
  10. ## 变量
  11. 在Python中，由于变量的类型是动态的。因此，变量给人的感觉更像是：存放数据的容器。<br />假设现在有一个容器，名为：`a`，那么a中既可以存放数字，也可以存放字符串等等
  12. ```python
  13. a = 1
  14. a = 'hello'

也可以使用如下所示的方式进行变量的赋值：

  1. a, b, c = 1, 2, 'hello'
  2. print(a)
  3. print(b)
  4. print(c)

image.png

运算符

算术运算符

除了加减乘除以外的，两个新的算术运算符：

  • 幂运算（**）
  • 整除运算（//） ```python print(10 2) print(10 3)

print(10 / 4) print(10 // 4) print(15 // 4)

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/21436600/1662039203314-6122fd24-7601-4205-b93b-c5af7f602356.png#clientId=ucd76dc74-fe48-4&from=paste&height=234&id=u64837ccc&originHeight=292&originWidth=626&originalType=binary&ratio=1&rotation=0&showTitle=false&size=18419&status=done&style=none&taskId=u6bc918bf-bb94-44f2-9e46-9093aabb207&title=&width=500.8)
  2. <a name="lsnpS"></a>
  3. ### 逻辑运算符
  4. Python中不再使用符号来进行逻辑运算，而是使用对应的英文单词进行逻辑运算
  6. - 与（and）
  7. - 或（or）
  8. - 非 （not）
  9. <a name="IpytO"></a>
  10. ### 成员运算符
  11. 成员运算符主要判断某个值是否在指定的序列中存在，主要由以下两个运算符组成：
  13. - `in`：如果在指定序列中找到值则返回`True`，反之返回`False`
  14. - `not in`：找不到返回`True`，反之返回`False`
  15. ```python
  16. my_list = [1, 2, 3, 4, 5]
  17. a = 1
  18. print(a in my_list)
  19. print(a not in my_list)

image.png

身份运算符

在Python中，我们可以通过id()函数来获取对象内存地址

  1. a = 1
  2. b = 1
  3. print(id(a))
  4. print(id(b))

而使用身份运算符，可以很方便的帮助我们比较两个对象的存储单元

  • is：判断两个变量是否引用同一块内存
  • is not：判断两个变量是否没有引用同一块内存

    条件语句

    唯一不同的是，在Python中else if变成了elif
    1. if 判断条件1:
    2.   执行语句1……
    3. elif 判断条件2:
    4.   执行语句2……
    5. elif 判断条件3:
    6.   执行语句3……
    7. else:
    8.   执行语句4……

    循环语句

    while循环基本相同，但可以与else语句一起使用： ```python num = 0 while num < 5: print(num, ‘ 小于5’) num += 1 else: print(num, ‘ 大于等于5’)
  1. `for`循环的理念与其他语言存在差异<br />**可用于遍历任何可迭代的对象（比如一个列表或者一个字符串）**
  2. > 个人理解：Python中的for循环更加类似于其他语言中的增强`for`循环，偏向于对列表中**每一个元素的遍历**
  4. 基础语法如下
  5. ```python
  6. for iterating_var in sequence:
  7.    statements(s)
  1. a = [1, 2, 3, 4]
  2. for item in a:
  3.     print(f'index is: {a.index(item)}, item is: {item}')

image.png

  1. a = 'hello,world'
  2. for ch in a:
  3.     print(ch, end=" ")

也可以使用其他语言的思想，使用索引的方式进行遍历
但是我们需要获取一段对应长度的序列
因此需要使用range函数
range函数一共可以接收3个参数

  1. for index in range(10):
  2.     print(index, end=" ")
  3. print("\n****************")
  5. for index in range(1, 5):
  6.     print(index, end=" ")
  7. print("\n****************")
  9. for index in range(1, 20, 3):
  10.     print(index, end=" ")
  11. print("\n****************")

image.png

  1. a = [1, 2, 3, 4, 5, 6]
  2. for index in range(len(a)):
  3.     print(a[index], end=" ")

数据容器

数据容器指的是可以存放数据的容器，在Python中主要有：列表list、字符串str、集合set、字典Dictionary、元组Tuple

字符串

可以通过单引号、双引号和三引号来创建字符串

截取字符串

可以使用[]来截取字符串的一部分（并且遵循的是左闭右开的原则）
基础语法如下：变量[头下标:尾下标]

  1. var1 = 'Hello World!'
  2. var2 = "Runoob"
  4. print ("var1[0]: ", var1[0])
  5. print ("var2[1:5]: ", var2[1:5])

字符串运算

  1. s1 = 'hello'
  2. s2 = 'world'
  3. s3 = 'bob'
  4. print('s1 + s2 =', s1 + s2)
  5. print('s1 * 2 =', s1 * 2)
  6. print(s1[1:4])
  7. print('\n', end="")
  8. print(r'\n')

image.png

字符串格式化

可以使用诸如%s、%d、%f等占位符来进行字符串的格式化操作

  1. print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

三引号定义的字符串，允许一个字符串跨越多行，并且在字符串中，可以包含换行符、制表符等其他的特殊字符。

  1. s = """
  2. hello,world
  3. i'm jack and my name is (\t)
  4. "" and '' is vary good
  5. end line is [\n]
  6. """
  7. print(s)

image.png

列表

序列是Python中最基本的数据结构，每个序列值都有对应的索引值
其中，最常见的两种序列的内置类型是：列表和元组
列表都可以进行的操作如下：

  • 索引
  • 切片
  • 加
  • 乘
  • 检查成员 ```python a = [1, 2, 3, 4] b = [1, 2]

    索引

    print(a[1], a[2], a[3])

    切片

    print(a[0:4])

    加法

    print(a + b)

    乘法

    print(a * 2 + b)

    判断成员

    print(2 in a) print(1 not in b)
  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/21436600/1662096230264-c6e1d17f-a4b0-4d45-9a0f-bc500f08c454.png#clientId=ua7287da8-75cf-4&from=paste&height=217&id=uc265bcf0&originHeight=271&originWidth=602&originalType=binary&ratio=1&rotation=0&showTitle=false&size=18825&status=done&style=none&taskId=ub8b5c02b-030d-467c-9e8e-9ae8b507455&title=&width=481.6)<br />除此之外，Python的列表中所存储的数据类型是不做限制的，可以同时存储数字、字符串，甚至列表等多种数据类型。<br />Python内置了以下函数对列表进行处理：
  3. - len
  4. - max
  5. - min
  6. - list
  8. [Python3 列表 | 菜鸟教程](https://www.runoob.com/python3/python3-list.html)
  9. <a name="RThTm"></a>
  10. ## 元组
  11. 元组和列表基本相似，但不同的地方在于**元组中的元素不可以被修改**<br />**使用**`**[]**`**来创建列表，而使用**`**()**`**来创建元组**
  12. > 当元组中只有一个元素的时候，需要在该元素后添加逗号`，`，否则括号会被当做运算符使用
  14. > - 元组中的值是不允许被修改的，但是如果将某个列表作为元素存于元组中，是可以对列表数据进行修改的
  15. > - 同样，元组中的元素是不可以被删除的，但是可以通过`del`关键字来删除整个元组
  17. 元组的其他操作与列表相同，不再赘述
  18. <a name="MpFMu"></a>
  19. ## 集合
  20. [Python3 集合 | 菜鸟教程](https://www.runoob.com/python3/python3-set.html)<br />与在数学中的定义相似，集合是一个**无序的不重复的元素序列**<br />可以使用`{}`或者`set()`函数来创建集合
  21. > 创建一个空集合必须要使用`set()`而不是`{}`，因为`{}`是用来创建一个空字典
  23. 可以利用集合`不重复`的特性，对列表进行去重
  24. ```python
  25. a = [1, 1, 1, 2, 3, 3, 4, 4, 5]
  26. a = list(set(a))
  27. print(a)

对集合中数据的增删改查

  • add/update：add可以添加某个元素，而update可以添加一个或者多个
  • remove/discard：remove可以删除某个元素（如果元素不存在则会报错），而discard删除不存在的元素的时候不会报错

    字典

    Python3 字典 | 菜鸟教程
    字典与其他语言中的HashMap相似，存储的一系列键值对的集合
    存储的形式如下所示：
    1. d = {key1 : value1, key2 : value2, key3 : value3 }
    使用{}或内置函数dict()来创建一个空字典 ```python my_dict = {‘name’: ‘yxr’, ‘age’: 18} print(my_dict[‘name’])

my_dict[‘school’] = ‘三峡大学’ print(my_dict[‘school’])

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/21436600/1662100332132-ea81a7d4-3481-40c3-9c7d-4ce097f2a790.png#clientId=ua7287da8-75cf-4&from=paste&height=214&id=u9daf7b17&originHeight=267&originWidth=686&originalType=binary&ratio=1&rotation=0&showTitle=false&size=18938&status=done&style=none&taskId=uea5db378-c171-47e8-aa1f-0a2226bacfb&title=&width=548.8)
  2. > 其中，增加和修改（更新）字典中元素的方法是一样的，都是直接通过设置键值对的方式
  3. > 删除字典中某个键对应的数据可以使用`del`关键字
  4. > 清空整个字典可以使用`clear()`方法
  5. > 删除整个字典可以使用`del`关键字
  7. <a name="SLFms"></a>
  8. # 函数
  9. <a name="E4F4t"></a>
  10. ## 函数声明和定义
  11. 函数的声明采用`def`关键字
  12. <a name="SxYsn"></a>
  13. ## 可变类型和不可变类型
  14. <a name="R8IRp"></a>
  15. ### 变量
  16. 在Python中，对变量的理解变得十分神奇（或者说“古怪”）
  17. ```python
  18. a=[1,2,3]
  20. a="Runoob"

以上代码中，[1,2,3] 是 List 类型，”Runoob“ 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

也就是说，Python中变量其实是类似于C语言中的指针，或者可以称之为“容器”，变量本身是不具有类型的，而其指向（或者说容纳）的数据是存在数据类型的

可变类型和不可变类型

  • 不可变类型：将变量a赋值a=5后再赋值a=10，这里实际是新生成了一个int值对象10，让a重新指向它，而不是修改a的值，相当于重新生成了a

  • 可变类型：变量赋值arr=[1,2,3,4]后再赋值arr[0]=6，是将list列表的第一个元素进行修改，而并没有影响到arr对象本身

    函数的参数传递

  • 不可变类型：类似于C++中的值传递，传递的只是变量的值，而不是变量本身

  • 可变类型：类似于C++中的引用传递，是将变量本身所传递过去 ```python def func1(a): a = 10

def func2(arr: list): arr.append(‘hello’)

a = 1 print(f’the value of a before is: {a}’) func1(a) print(f’the value of a after is: {a}’)

aa = [1, 2, 3] print(f’the value of aa before is: {aa}’) func2(aa) print(f’the value of aa after is: {aa}’)

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/21436600/1662101726070-e0c2f1e9-59d9-494e-9fb2-f1c3eb87cb38.png#clientId=uba29c7b2-c195-4&from=paste&height=248&id=u7ffc1a10&originHeight=310&originWidth=838&originalType=binary&ratio=1&rotation=0&showTitle=false&size=31572&status=done&style=none&taskId=u331d4ad4-1446-40da-a789-44982f68d7c&title=&width=670.4)
  2. <a name="OESm5"></a>
  3. ## 参数
  4. Python中共有4种参数类型：
  6. - 必需参数
  7. - 关键字参数
  8. - 默认参数
  9. - 不定长参数
  10. <a name="AxMvM"></a>
  11. ### 必需参数
  12. 必须参数即是最普通的一种参数类型，调用时的数量必须和声明的时候一样，但是顺序可以不一样。
  13. <a name="YQ13s"></a>
  14. ### 关键字参数
  15. 必须参数传递的顺序可以与定义时不同的原因就在于，我们可以使用关键字来指明，我们传递的是哪一个参数
  16. ```python
  17. def print_info(uname, uage):
  18.     print(f'name is: {uname}')
  19.     print(f'age is: {uage}')
  22. name = 'yxr'
  23. age = 20
  25. print_info(uage=20, uname=name)

默认参数

即，可以给某个参数设置默认值，当调用该函数的时候没有传递这个参数的值时，则使用默认值

  1. #可写函数说明
  2. def printinfo( name, age = 35 ):
  3.    "打印任何传入的字符串"
  4.    print ("名字: ", name)
  5.    print ("年龄: ", age)
  6.    return
  8. #调用printinfo函数
  9. printinfo( age=50, name="runoob" )
  10. print ("------------------------")
  11. printinfo( name="runoob" )

不定长参数

有些时候，我们所定义的函数，所接受到的参数个数可能是不固定的，也就是不定长参数
有两种接收不定长参数的方法，分别是使用元组和字典进行接收

  • 加了*号的参数会以元组的形式导入，存放所有未命名的参数
  • 加了*号的参数会以字典的形式导入 ```python def func_test_1(arg1, tt): print(f’arg1 is:{arg1}’) print(f’tuple is:{tt}’)

def func_test_2(arg1, **dd): print(f’arg1 is:{arg1}’) print(f’dd is:{dd}’)

name = ‘yxr’ age = 20

print_info(uage=20, uname=name) print(“”) func_test_1(10, 20, 30, 40) func_test_2(10, name=’yxr’, age=20)

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/21436600/1662102668972-635f1ed1-3639-4ca0-a1f7-9b7686acf938.png#clientId=uba29c7b2-c195-4&from=paste&height=107&id=u1e974ca4&originHeight=134&originWidth=484&originalType=binary&ratio=1&rotation=0&showTitle=false&size=12577&status=done&style=none&taskId=u322af2da-0f13-401a-9830-c7cf11d1cbf&title=&width=387.2)
  2. <a name="RPMdX"></a>
  3. ## 匿名函数
  4. 在Python中，可以使用`lambda`表达式来创建匿名函数，并且`lambda`表达式只能写一条语句
  5. ```python
  6. # func3用来比较两个参数的大小
  7. func3 = lambda a, b: a > b
  9. print(func3(1, 2))
  10. print(func3(1, 1))
  11. print(func3(2, 1))

除此之外，还可以通过将匿名函数封装到函数的返回值中，通过传入不同的参数来创建不同的匿名函数

  1. def func(n):
  2.     return lambda a: a * n
  3. lambda1 = func(2)
  4. lambda2 = func(3)
  6. print(lambda1(11))
  7. print(lambda2(12))

返回值

return语句用于退出函数
如果某个函数不使用return语句，那么默认返回None
同其他语言一样，可以将函数的运行结果作为返回值返回以外，Python还支持多个返回值
多个返回值将使用元组进行包装、返回