python基础学习笔记

本文类比c语言讲解python

一.变量和类型

前缀小知识：

注意：1.python写每一行代码时，结尾不需要 ; 这点是和c语言有很大区别的

2.代码的缩进（就是每行代码前面的空格）是非常重要的后文会提到

1.定义变量

注意: 和C/C++ 等语言不同, Python 变量的类型不需要显式指定, 而是在赋值的时候确定的.

a = 10

        1. = 为赋值运算符, 表示把 = 右侧的数据放到 = 左侧的空间中.

        2. a 为变量名. 当我们创建很多个变量的时候, 就可以用名字来进行区分.

a,b = 10,'hh'
print(a)#输出 10
print(b)#输出 hh

这是python独有的机制：称为”多元赋值"，左边是变量名，右边是值，让后顺序是一一对应的

注意：变量名要遵循一下规则

       1. 变量名由数字字母下划线构成.

       2. 数字不能开头.

       3. 变量名不能和 "关键字" 重复.

       4. 变量名大小写敏感. num 和 Num 是两个不同的变量名.

2.使用变量

前缀小知识：

1.这里的print是个内置函数用于输出到屏幕的（后面会详细讲解）

     （1） 读取变量的值

a = 10
print(a)

     （2） 修改变量的值

a = 20
print(a)

注意：python中定义变量和修改变量代码是一样的

     （3） 变量对变量赋值

a = 10
b = 20
a = b

print(a)
print(b)

 3.变量的类型

前缀小知识：

1.type（变量名）返回的是变量的类型

2.#是用于python的注释

（1）整数（int）

a = 10
print(type(a))#输出：<class 'int'>

注意: 和 C++ / Java 等语言不同, Python 的 int 类型变量, 表示的数据范围是没有上限的. 只要内存足够大, 理论上就可以表示无限大小的数据.

（2）浮点数（float）

a = 0.5
print(type(a))#输出：<class 'float'>

注意: 和 C++ / Java 等语言不同, Python 的小数只有 float 一种类型, 没有 double 类型. 但是实际上Python 的 float 就相当于 C++ / Java 的 double, 表示双精度浮点数.

（3）字符串（str）

a = 'hello'
print(type(a))#输出：<class 'str'>

注意: 在 Python 中, 单引号构成的字符串和双引号构成的字符串, 没有区别. 'hello' 和 "hello" 是完全等价的.

a = 'hello'
print(len(a))#输出：5

这里的len函数是用来计算字符串长度的，但是len不仅仅可以计算字符串长度，后文会讲解其他用法。

a = 'hello'
b = 'world'
print(a + b)#输出：helloworld

在python中字符串是可以相加的，支持+号自然会支持+=，这点和c++中的string类型类似

但是注意：不能用str类型的变量去加整数/浮点数

（4）布尔（bool）

        布尔类型是一个特殊的类型, 取值只有两种, True (真) 和 False (假).

a = True
print(type(a))#输出<class 'bool'>
b = False
print(type(b))#输出<class 'bool'>

（5）其他

除了上述类型之外, Python 中还有 list（列表）, tuple（元组）, dict（字典）, 自定义类型 等等. 我们后文再介绍

4.动态类型的变量

        在 Python 中, 一个变量是什么类型, 是可以在 "程序运行" 过程中发生变化的. 这个特性称为         "动态类型" .（这也是python独有的机制）

a = 10
print(type(a))#输出 <class 'int'>
a = 'hello'
print(type(a))#输出 <class 'str'>

        注：在程序执行过程中, a 的类型刚开始是 int, 后面变成了 str.

注意：C++/Java 这样的语言则不允许这样的操作. 一个变量定义后类型就是固定的了. 这种特性则称为 "静态类型".

对动态类型的评价：

动态类型特性是一把双刃剑.

对于中小型程序, 可以大大的解约代码量(比如写一段代码就可以同时支持多种类型).

对于大型程序, 则提高了模块之间的交互成本. (程序猿 A 提供的代码难以被 B 理解).

二.注释

1.注释行

        使用 # 开头的行都是注释.

# 这是一行注释.

2.文档注释

        1.使用三引号引起来的称为 "文档字符串", 也可以视为是一种注释.

        2.可以包含多行内容,

        3.一般放在 文件/函数/类 的开头. " " " 或者 ''' 均可 (等价).、

"""
这是文档字符串
这是文档字符串
"""

三.输入和输出

1.输出

      1.Python 使用 print 函数输出到控制台.

print('hello')

        2.不仅能输出一个字符串, 还可以输出一个其他类型的变量

a = 10
print(a)#输出 10
b = True
print(b)#输出 True

        3.更多的时候, 我们希望能够输出的内容是混合了字符串和变量的.

num = 10
print(f'num = {num}')#输出 num = 10

        4.print还可以连续打印变量

a = 10
b = 2.5
c = True
d = "rhm"
print(a,b,c,d,100)#输出：10 2.5 True rhm 100

2.输入

        python 使用 input 函数, 从控制台读取用户的输入.

num = 0
num = input('请输入一个整数: ')
print(f'你输入的整数是 {num}')

1.input 的参数相当于一个 "提示信息", 也可以没有.

2.input 的返回值就是用户输入的内容. 是字符串类型.

a = input('请输入第一个整数: ')#输入 10
b = input('请输入第二个整数: ')#输入 20
print(f'a + b = {a + b}')#输出 1020

因为input返回的是字符串类型所以这里输出表现出来的是字符串相加

这里我们便引出了一个新的知识点：类型转化,上代码

a = input('请输入第一个整数: ')#输入 10
b = input('请输入第二个整数: ')#输入 20
print(f'a + b = {int(a) + int(b)}')#输出 30

所以这里类型转换的格式是：类型（变量名），然后遇见其他的需要转换的情况就可以照本宣科了

四.运算符

1.算术运算符

 +  -  *  /  %  **  // 

使用这些运算符号的注意事项：

1: / 中不能用 0 作为除数. 否则会抛出异常
2. python中的 / 是可以算出小数的，这点和c/c++是相反的

3. ** 是平方和运算符号，不仅能算整数的次方还可以算小数的次方

4. 负数取余是正数，和c/c++是不同的。

print(-7 % 2) #输出 1

5. // 是取整除法(也叫地板除). 整数除以整数, 结果还是整数(舍弃小数部分, 并向下取整. 不是四舍五入)注意：就是正常算出来的数字向下取整入3.5变成3，-3.5 变成 -4 这点也是和c/c++相反的。

print(7 // 2)#输出：3
print(-7 // 2)#输出: -4

        没讲解的部分与c语言一样

2.关系运算符

< <= > >= == !=

使用运算符号的注意事项：

1.关系运算符号的运算结果是bool类型的变量，正确返回True，错误返回False

2.不仅可以比较数字，也可以比较字符串，字符串的比较是按照字典序比较的。

3.直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / Java 不同)

4. 浮点数不要用 == 比较相等，因为浮点数在储存的过程中是不精确的。像下面这段代码

print(0.1 + 0.2)#输出 0.30000000000000004

所以我们一般这样比较：

a = 0.1 + 0.2
b = 0.3
print(-0.000001 < (a - b) < 0.000001)#这种连续的写法后面会讲

        没讲的部分和c语言类似

3.逻辑运算符

and or not  #这三个运算符号和对应的英文意思一样

讲解： 

1. and 并且. 两侧操作数均为 True, 最终结果为 True. 否则为 False. (一假则假)

2. or 或者. 两侧操作数均为 False, 最终结果为 False. 否则为 True. (一真则真)

3. not 逻辑取反. 操作数本身为 True, 则返回 False. 本身为 False, 则返回 True
此处说的 "并且" 和 "或者", 就是我们日常生活中使用的 "并且" 和 "或者".

想象一下未来丈母娘问你要彩礼, 什么叫做 "有房并且有车", 什么叫做 "有房或者有车".

不多说了牛马们该写代码了😭😭😭。

4.a < b and b < c 这个操作等价于 a < b < c . 这个设定和大部分编程语言都不相同。

注意事项：

短路求值：

对于 and, 如果左侧表达式为 False, 则整体一定为 False, 右侧表达式不再执行.

对于 or, 如果左侧表达式为 True, 则整体一定为 True, 右侧表达式不再执行.

4.赋值运算符

（1）= 的使用

        1.链式赋值

a = b = 10

        2.多元赋值

a, b = 10, 20

        3.多元赋值和更方便的实现两个变量的交换，代码如下

a = 10
b = 20
a, b = b, a

（2）复合运算符号 

+= -= *= /= %=  #这些运算符的用法和c/c++类似

注意: 像 C++ / Java 中, 存在 ++ -- 这样的自增/自减运算符. Python 中则不支持这种运算. 如果需要使用,则直接使用 += 1 或者 -= 1

5. 位运算符

&  |  ~  ^  <<  >>  #这些运算符的用法和c/c++类似

五.条件语句

1.关键字

条件语句的关键字：if    else elif

注意：

1. if 后面的条件表达式, 没有 ( ), 使用 : 作为结尾.

2. if / else 命中条件后要执行的 "语句块", 使用 缩进 (通常是 4 个空格或者 1 个 tab)来表示, 而不是 { }对于多条件分支.（这里一定要注意和c/c++完全不同）

3.对于多条件分支, 不是写作 else if, 而是 elif (合体了).

（1）if

if expression:
    do_something1
    do_something2
next_something

块语句： do_something1，do_something2前面都有四个空格所以这两句代码都包含在if的块语句里面，只要if语句成立这两句代码就可以执行，而next_something前没有缩进，所以在if语句的外面，if语句无论是否成立都可以执行。

所以缩进在python里面是非常重要的，

然后块语句在函数中也是非常重要的一个概念。

注释：

1. 如果 expression 值为 True, 则执行 do_something1， do_something2， next_something

2. 如果 expression 值为 False, 则只执行 next_something, 不执行do_something1， do_something2

（2）if-else

if expression:
    do_something1
else:
    do_something2

注释：

1. 如果 expression 值为 True, 则执行 do_something1

2. 如果 expression 值为 False, 则执行 do_something2

（3）if-elif-else

if expression1:
    do_something1
elif expression2:
    do_something2
else:
    do_something3

注释：

1. 如果 expression1 值为 True, 则执行 do_something1
2. 如果 expression1 值为 False, 并且 expression2 为 True 则执行 do_something2

3. 如果 expression1 值为 False, 并且 expression2 为 False 则执行 do_something3

 为了让大家更好的熟悉块语句，出个例题：

a = input("请输入第一个整数: ")
b = input("请输入第二个整数: ")
if a == "1":
    if b == "2":
        print("hello")
    print("world")
print("python")

print("hello") 具有两级缩进, 属于 if b == "2" 条件成立的代码块.

print("world") 具有一级缩进, 属于 if a == "1" 条件成立的代码块.

print("python") 没有缩进, 无论上述两个条件是否成立, 该语句都会执行.

所以执行结果：

1.如果输入a为1，b为2，输出 hello world python

2.如果输入a为1，b不为2，输出 hello python

3.如果输入a不为1，b不用管，输出 python

2.空语句（pass）

因为在写if语句的时候可能写了条件，但是进入了这个条件啥都不用执行，但是这位置是不能空着的，所以就有了空语句。代码案例如下：

a = int(input("请输入一个整数:"))
if a != 1:
    pass #这里不能空着必须要有代码，所以这里用空语句填充
else:
    print("hello")

六.循环语句

注意：python循环里面有一个小特点和c/c++里面有个不同的地方，python在循环里创建变量出循环是不会被销毁的，但是c/c++在循环里面出循环就会被销毁

1.while循环

基本语法格式

while 条件:
    循环体

 注意：这里的循环体要注意缩进，在缩进的代码块里面才是循环体

 条件为真, 则执行循环体代码.

 条件为假, 则结束循环.

代码示例1：计算1到100的和

sum = 0
num = 1
while num <= 100:
    sum += num
    num += 1
print(sum)

 代码示例2：求 1! + 2! + 3! + 4! + 5!

        这里运用了两重循环：一定要注意好缩进

num = 1
sum = 0
while num <= 5:
    factorResult = 1
    i = 1
    while i <= num:
        factorResult *= i
        i += 1
    sum += factorResult
    num += 1
print(sum)

2.for循环

        基本语法格式

for 循环变量 in 可迭代对象:
    循环体

 注意：这里的循环体要注意缩进，在缩进的代码块里面才是循环体 

 1. python 的 for 和其他语言不同, 没有 "初始化语句", "循环条件判定语句", "循环变量更新语    句", 而是更加简单

  2. 所谓的 "可迭代对象", 指的是 "内部包含多个元素, 能一个一个把元素取出来的特殊变量"

        代码示例1： 打印1~10

for i in range(1, 11):
    print(i)

注释：使用 range 函数, 能够生成一个可迭代对象. 生成的范围是 [1, 11), 也就是 [1, 10] 

       代码示例2：打印 2, 4, 6, 8, 10

for i in range(2, 12, 2):
    print(i)

注释：第三个参数是步长这里设置的步长是2，所以这里没有传步长的时候默认步长是1，为什么这里有时候可以填两个参数或者三个参数呢，这涉及到后文会讲的函数的默认参数。

       代码示例3：  打印10~1

for i in range(10, 0, -1):
    print(i)

注意：步长也可以是负数 

3.break和continue

        和c语言的用法一样这里不作多的解释

七.函数

1.语法格式：注意缩进和前面的一样

1.创建函数/定义函数

def 函数名(形参列表):
    函数体
    return 返回值   #也可以没有返回值

 2.调用函数/使用函数

函数名(实参列表) # 不考虑返回值
返回值 = 函数名(实参列表) # 考虑返回值

3.函数在使用时需要注意的点

1.函数定义并不会执行函数体内容, 必须要调用才会执行. 调用几次就会执行几次 

2.函数必须先定义, 再使用.

2.函数参数

在函数定义的时候, 可以在 ( ) 中指定 "形式参数" (简称 形参), 然后在调用的时候, 由调用者把 "实际参数" (简称 实参) 传递进去.

def test(a, b, c):
    print(a, b, c)

test(1,2,3)

1. 一个函数可以有一个形参, 也可以有多个形参, 也可以没有形参.

2. 一个函数的形参有几个, 那么传递实参的时候也得传几个. 保证个数要匹配.

3.和 C/C++ / Java 不同, Python 是动态类型的编程语言, 函数的形参不必指定参数类型. 换句话说, 一个函数可以支持多种不同类型的参数.代码案例如下：

def test(a):
    print(a)

test(10)#打印 10
test('hello')# 打印 hello
test(True)# 打印 True

3.函数的返回值

        函数的参数可以视为是函数的 "输入", 则函数的返回值, 就可以视为是函数的 "输出" .

def calcSum(beg, end):
    sum = 0
    for i in range(beg, end + 1):
        sum += i
    return sum
result = calcSum(1, 100)   #用变量result接受函数的返回值
print(result) #然后打印1到100的求和

1.一个函数中可以有多个 return 语句，执行到 return 语句, 函数就会立即执行结束, 回到调用位置

# 判定是否是奇数
def isOdd(num):
    if num % 2 == 0:
        return False
    return True

result = isOdd(10)
print(result)  #打印 False，这段代码执行了if语句就返回了

2.一个函数是可以一次返回多个返回值的. 使用 , 来分割多个返回值.（这是python独有的机制）

def getPoint():
    x = 10
    y = 20
    return x, y
a, b = getPoint()  #这就是前面的多元赋值

3.如果只想关注其中的部分返回值, 可以使用 _ 来忽略不想要的返回值

def getPoint():
    x = 10
    y = 20
    return x, y
_, b = getPoint()

4.变量作用域

1.变量只能在所在的函数内部生效

def getPoint():
    x = 10
    y = 20
    return x, y

getPoint()
print(x, y)

上面这一段代码运行后会显示错误，因为在函数 getPoint() 内部定义的 x, y 只是在函数内部生效. 一旦出了函数的范围, 这两个变量就不再生效了.

2.在不同的作用域中, 允许存在同名的变量

x = 20

def test():
    x = 10
    print(f'函数内部 x = {x}')#打印 x = 10

test()
print(f'函数外部 x = {x}')打印 x = 20

上面的代码，虽然名字相同, 实际上是不同的变量
注意：

1.在函数内部的变量, 也称为 "局部变量"

2.不在任何函数内部的变量, 也称为 "全局变量"

3.如果函数内部尝试访问的变量在局部不存在, 就会尝试去全局作用域中查找

x = 20
def test():
    print(f'x = {x}')#打印 x = 20

test()

 4.如果是想在函数内部, 修改全局变量的值, 需要使用 global 关键字声明

x = 20

def test():
    global x
    x = 10
    #不能这样写
    #global x = 10
    print(f'函数内部 x = {x}')

test()
print(f'函数外部 x = {x}')

注意：如果此处没有 global , 则函数内部的 x = 10 就会被视为是创建一个局部变量 x, 这样就和全局变量 x 不相关了。

5.参数的默认值

Python 中的函数, 可以给形参指定默认值.带有默认值的参数, 可以在调用的时候不传参

def add(x, y, debug=False):
    if debug:
        print(f'调试信息: x={x}, y={y}')
    return x + y

print(add(10, 20)) #这里不会打印调试信息
print(add(10, 20, True)) #这里会打印调试信息

 注意：带有默认值的参数需要放到没有默认值的参数的后面

6.关键字参数 

在调用函数的时候, 需要给函数指定实参. 一般默认情况下是按照形参的顺序, 来依次传递实参的.但是我们也可以通过关键字参数, 来调整这里的传参顺序, 显式指定当前实参传递给哪个形参，而这样传参就不用管顺序了。（这是python独有的机制）

def test(x, y):
    print(f'x = {x}')
    print(f'y = {y}')

test(x=10, y=20) #输出 x = 10，y = 20
test(y=100, x=200) #输出 x = 100，y = 200

 总结：

函数是编程语言中的一个核心语法机制. Python 中的函数和大部分编程语言中的函数功能都是基本类似的，然后还有函数栈帧，可以点击这里进行学习，学了函数栈帧可以更好的帮助我们理解函数的调用和销毁。

八.列表和元组

1.列表（list）是什么，元组（tuple）是什么

1. 列表我们可以理解为c语言中的数组，但是比数组更高级，一个列表可以储存不同的数据类型。

2. 元组和列表相比, 是非常相似的, 只是列表中放哪些元素可以修改调整, 元组中放的元素是创建元组的时候就设定好的, 不能修改调整

2.创建列表

1.创建列表有两种方式

a1 = [ ]  #方法1
a2 = list()   #方法2
print(type(a1)) #打印 <class 'list'>
print(type(a2)) #打印 <class 'list'>

 如果需要往里面设置初始值, 可以直接写在 [ ] 当中,每个元素之间用，隔开。

a1 = [1, 2, 3, 4]
a2 = list([1,2,3,4]) #写起来麻烦一点，所以一般不用
print(a1) #print函数可以直接打印列表
print(a2) 

列表中存放的元素允许是不同的类型（这是python独有的语法）

alist = [1, 'hello', True]
print(alist)  #输出 [1, 'hello', True]

3.访问下标

        可以通过下标访问操作符 [ ] 来获取到列表中的任意元素.

alist = [1, 2, 3, 4]
print(alist[2])  #输出 3

 注意：下标是从0开始计算的

         通过下标不光能读取元素内容, 还能修改元素的值

alist = [1, 2, 3, 4]
alist[2] = 100
print(alist)  #输出 [1,2,100,4]

        如果下标超出列表的有效范围, 会抛出异常,就像c/c++的数组一样下标访问不能越界。

        使用len函数可计算列表的长度

a = [1, 2, 3, 4]
print(len(a))  #输出 4

         下标可以取负数. 表示 倒数第几个元素

alist = [1, 2, 3, 4]
print(alist[3])   #输出 4
print(alist[-1])  #输出 4

4.切片操作

切片是啥:

        通过下标操作是一次取出里面第一个元素.

        通过切片, 则是一次取出一组连续的元素, 相当于得到一个子列表

        使用 [ : ] 的方式进行切片操作

alist = [1, 2, 3, 4]
print(alist[1:3])  #打印  [2,3]

注释：

alist[1:3] 中的 1:3 表示的是 [1, 3) 这样的由下标构成的前闭后开区间.

也就是从下标为 1 的元素开始(2), 到下标为 3 的元素结束(4), 但是不包含下标为 3 的元素.所以最终结果只有 2, 3

        切片操作中可以省略前后边界

alist = [1, 2, 3, 4]
# 省略后边界, 表示获取到列表末尾.
print(alist[1:])   #打印 [2,3,4]
# 省略前边界, 表示从列表开头获取.
print(alist[:-1]) # 打印 [1,2,3]
# 省略两个边界, 表示获取到整个列表.
print(alist[:])   # 打印 [1,2,3,4]

        切片操作还可以指定 "步长" , 也就是 "每访问一个元素后, 下标自增几步"

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1])  #打印 [1,2,3,4,5,6,7,8,9,10]
print(alist[::2])  #打印 [1,3,5,7,9]
print(alist[::3])  #打印 [1,4,7,10]
print(alist[::5])  #打印 [1,6]

        切片操作指定的步长还可以是负数, 此时是从后往前进行取元素. 表示 "每访问一个元素之后,         下标自减几步"

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::-1])  #打印 [10,9,8,7,6,5,4,3,2,1]
print(alist[::-2])  #打印 [10,8,6,4,2]
print(alist[::-3])  #打印 [10,7,4,1]
print(alist[::-5])  #打印 [10,5]

        如果切片中填写的数字越界了, 不会有负面效果. 只会尽可能的把满足条件的元素过去到

alist = [1, 2, 3, 4]
print(alist[100:200])

5.遍历列表元素

"遍历" 指的是把元素一个一个的取出来, 再分别进行处理

        最简单的办法就是使用 for 循环

alist = [1, 2, 3, 4]

for elem in alist:
    print(elem)

         也可以使用 for 按照范围生成下标, 按下标访问

alist = [1, 2, 3, 4]
for i in range(0, len(alist)):
    print(alist[i])

        还可以使用 while 循环. 手动控制下标的变化

alist = [1, 2, 3, 4]
i = 0
while i < len(alist):
    print(alist[i])
    i += 1

6.新增元素

前缀小知识：

什么是 "方法" (method)

方法其实就是函数. 只不过函数是独立存在的, 而方法往往要依附于某个 "对象".

下面的代码就会演示 alist.append , append 就是依附于 alist, 相当于是 "针对 alist 这个列表, 进行尾插操作"

        使用 append 方法, 向列表末尾插入一个元素(尾插).

alist = [1, 2, 3, 4]
alist.append('hello')
print(alist)   #打印 [1,2,3,4,'hello']

        使用 insert 方法, 向任意位置插入一个元素

alist = [1, 2, 3, 4]
alist.insert(1, 'hello')
print(alist)   #打印 [1,'hello',2,3,4]

注释：insert 第一个参数表示要插入元素的下标 

如果insert的第一个参数超过了列表的下标范围，就会变成尾插

7.查找元素

        使用 in 操作符, 判定元素是否在列表中存在. 返回值是布尔类型.

alist = [1, 2, 3, 4]
print(2 in alist)  #打印 True
print(10 in alist)  #打印 False

使用 index 方法, 查找元素在列表中的下标. 返回值是一个整数. 如果元素不存在, 则会抛出异常

alist = [1, 2, 3, 4]
print(alist.index(2))   #打印 1
print(alist.index(10))  #报错出现异常

8.删除元素

        使用 pop 方法删除最末尾元素

alist = [1, 2, 3, 4]
alist.pop()
print(alist)  #打印 [1,2,3]

        pop 也能按照下标来删除元素

alist = [1, 2, 3, 4]
alist.pop(2)
print(alist)  #打印 [1,2,4]

        使用 remove 方法, 按照值删除元素

alist = [1, 2, 3, 4]
alist.remove(2)
print(alist)  #打印 [1,3,4]

 注意：这个删除时从左往右删除，删除第一个2

9.连接列表

        使用 + 能够把两个列表拼接在一起.

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
print(alist + blist)   #打印 [1,2,3,4,5,6,7]

注意：此处的 + 结果会生成一个新的列表. 而不会影响到旧列表的内容 

        使用 extend 方法, 相当于把一个列表拼接到另一个列表的后面

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
alist.extend(blist)  #打印 [1,2,3,4,5,6,7]
print(alist)   #打印 [1,2,3,4]
print(blist)   #打印 [5,6,7]

注意：a.extend(b) , 是把 b 中的内容拼接到 a 的末尾. 不会修改 b, 但是会修改 a.

10.元组

        元组使用 ( ) 来表示.

#元组的定义
atuple = ( )
atuple = tuple()

         元组不能修改里面的元素, 列表则可以修改里面的元素

因此, 像读操作,比如访问下标, 切片, 遍历, in, index, + 等, 元组也是一样支持的.

但是, 像写操作, 比如修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持

         另外, 元组在 Python 中很多时候是默认的集合类型. 例如, 当一个函数返回多个值的时候

def getPoint():
    return 10, 20

result = getPoint()
print(type(result))    #输出 <class 'tuple'>

 可以看出函数的返回的类型是元组的类型

        最后为什么有了列表还要有元组呢 

1.你有一个列表, 现在需要调用一个函数进行一些处理. 但是你有不是特别确认这个函数是否会把你的列表数据弄乱. 那么这时候传一个元组就安全很多.

2.我们马上要讲的字典, 是一个键值对结构. 要求字典的键必须是 "可hash对象" (字典本质上也是一个hash表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行

九.字典

1.字典是什么

        字典是一种存储 键值对 的结构.这个和c++里面的map有点类似

2.创建字典

        创建一个空的字典. 使用 { } 表示字典

a = { }
b = dict()

print(type(a))
print(type(b))

        也可以在创建的同时指定初始值

        键值对之间使用 , 分割, 键和值之间使用 : 分割. (冒号后面推荐加一个空格).

        使用 print 来打印字典内容

student = { 'id': 1, 'name': 'zhangsan' }
print(student)   #输出 { 'id': 1, 'name': 'zhangsan' }

        为了代码更规范美观, 在创建字典的时候往往会把多个键值对, 分成多行来书写

student = {
    'id': 1,
    'name': 'zhangsan'
}

3.查找key

        使用 in 可以判定 key 是否在 字典 中存在. 返回布尔值

student = {
    'id': 1,
    'name': 'zhangsan',
}
print('id' in student)   #输出 True
print('score' in student)  #输出 False

        使用 [ ] 通过类似于取下标的方式, 获取到元素的值. 只不过此处的 "下标" 是 key. (可能是整数,         也可能是字符串等其他类型).

student = {
    'id': 1,
    'name': 'zhangsan',
}
print(student['id'])   #输出 1
print(student['name'])  #输出  zhangsan

         如果 key 在字典中不存在, 则会抛出异常

student = {
    'id': 1,
    'name': 'zhangsan',
}

print(student['score'])  #直接报错

4.新增/修改元素

        使用 [ ] 可以根据 key 来新增/修改 value

        1.如果 key 不存在, 对取下标操作赋值, 即为新增键值对

student = {
    'id': 1,
    'name': 'zhangsan',
}
student['score'] = 90
print(student) #输出 {'id': 1,'name': 'zhangsan',‘score’ : 90}

        2. 如果 key 已经存在, 对取下标操作赋值, 即为修改键值对的值

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
student['score'] = 90
print(student)  #输出 {'id': 1,'name': 'zhangsan',‘score’ : 90}

5.删除元素

        使用 pop 方法根据 key 删除对应的键值对.

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
student.pop('score')
print(student) #输出 {'id': 1,'name': 'zhangsan'}

6.遍历字典元素

        直接使用 for 循环能够获取到字典中的所有的 key, 进一步的就可以取出每个值了

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
for key in student:
    print(key, student[key])
#输出
# id 1
# name zhangsan
# score 80

7.取出所有的key和value

        使用 keys 方法可以获取到字典中的所有的 key

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
print(student.keys())   #输出 dict_keys(['id', 'name', 'score'])

注释：此处 dict_keys 是一个特殊的类型, 专门用来表示字典的所有 key. 大部分元组支持的操作对于dict_keys 同样适用

        使用 values 方法可以获取到字典中的所有 value

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
print(student.values())   #输出 dict_values([1, 'zhangsan', 80])

注释：此处 dict_values 也是一个特殊的类型, 和 dict_keys 类似

        使用 items 方法可以获取到字典中所有的键值对

student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 80
}
print(student.items())  #输出 dict_items([('id', 1), ('name', 'zhangsan'), ('score', 80)])

注释：此处 dict_items 也是一个特殊的类型, 和 dict_keys 类似.

8.合法的key类型

不是所有的类型都可以作为字典的 key，必须要是一个可哈希的类型才可以.
可hash的类型意思是，一个对象可以用hash函数可以算出对应的hash值

因为字典的底层就是哈希表

注意：列表和字典都是不可hash类型

最后这是python的官方文档  可以用于参考学习

原文地址：https://blog.csdn.net/2301_81230656/article/details/143468163

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！