“!!!保姆级教程·Python·从0开始到精通基础!!!“ “一篇文章全部学完!“ 详细过程 各种注意批注 为您的python基础学习保驾护航!

目录

 常量和表达式

变量和类型 

变量是什么

变量的语法

定义变量

变量命名的规则

使用变量 

 变量的类型

整数

 浮点数

字符串

布尔类型

其它

为什么要有这些类型?

动态类型特征

两面性

注释

注释是什么

    作用        

 注释的语法

注释的规范

输入输出 

 和用户交互

通过控制台输出

通过输入台输入

 运算符

算数运算符

关系运算符 

逻辑运算符 

 赋值运算符

        其它

顺序语句

 条件语句

语法格式

 缩进和代码块

空语句pass

循环语句

while循环

 for循环

continue 和 break 

函数

函数是什么

语法格式

函数参数

函数的返回值

         一个函数中可以有多个返回规则

变量的作用域 

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

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

        但是函数里也可以使用全局变量

​编辑 如果要修改全局变量 需要用到global

 函数的执行过程

 链式调用 与 嵌套调用

函数递归

参数默认值

 关键字参数

 列表和元组

列表和元组分别是什么

创建列表

访问下标

 切片操作

遍历列表元素

新增元素 

查找元素

 删除元素

 列表连接

元组

字典 

字典是什么

创建字典

 查找key

新增或修改元素 

删除元素

遍历字典元素 

取出所有的key和value 

合法的key类型 

文件 

文件是什么

文件路径

 打开文件

关闭文件

写文件 

读文件 

上下文管理器

 常量和表达式

           Python在初学时可以当作一个计算器用于打印和计算

print(5+5-1)
print(5+5*1)
print(5 / 5 - 1)

 解释：

         1.print是Python的内置函数 我们直接使用就行

         2.在括号内可以使用任意的四则运算符，它怎么都可以计算

         3.在运算符于数字之间空格是否存在都不影响最终结构

注意：空格的意义

          ·空格在这里存在的意义是影响代码的美观性

          ·代码的美观性影响可读性有助于后期的维护和修正

在Python中 它不服C语言的一些运算规则

           它放弃了 整数 除以 整数 只会是 整数 的规则

           而且在编程中没有四舍五入的规则 上面的0.0也是浮点数

           浮点数是按照IEEE754标准的规则，这个规则是存在误差的

此外：

           我输入的这三行代码就是表达式，计算出的结果就是表达式的值

            5 1 这样的数字是字面值常量

            四则运算的符号 是运算符或者操作符

变量和类型 

变量是什么

       变量是在计算复杂程序过程中，用于保存中间结果的东西，这个东西一般是可变的量，也就是变量。

        例如：

                计算方差

                 1.计算平均值

                 2.计算每个数字与平均值的差值再平方

                 3.相加每一项平方值

                 4.除项数

Average = (77.5+88.5+99.5+100.5)/4
Total = (77.5-Average)**2 + (88.5-Average)**2 + (99.5-Average)**2 + (100.5-Average)**2
Result = Total / 3
print(Result)

注意：

          · 其中 Averang Total Result 都是变量

          · 我们的行为是给变量赋值

          · **2是求平方和 **3就是求3次方 以此类推

变量是一个可以用来存储数据的空间，它会占用在内存上

变量的语法

定义变量

 Average = (77.5+88.5+99.5+100.5)/4

这就算是定义变量了  

       注意 “=” 是“赋值运算符” 不是用于比较的

变量命名的规则

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

         2.变量不能由数字开头，不能包含特殊符号（a1可以，1a就不可以，a+a也不可以）

         3.变量名不能和关键字重复（在语法中有特点含义的单词）

         4.变量名区分大小写的，比如A和a就不是一个变量

         5.给变量命名的时候尽量使用有意义的单词来命名，从名字看功能能更有助于后期的维护

使用变量 

         读取变量的值

a = 0

print（a）

          系应该变量的值

a = 20

print（a）

         第一次使用=是创建定义变量 第二次对变量使用=是修改变量

也可以给变量赋另一个变量的值

a = 0

b = 10

a = b

print（a）

 变量的类型

python中变量的类型不需要再定义的时候声明，只需要初始化语句它自动定义

整数

a = 0

print（type（a））

 type也是python的内置函数，可以用来查看变量类型，p语言的int数值可以无限大

 浮点数

a = 0.0
print(type(a))

 python的小数只有这么一种类型，没有double类型

字符串

a = '0.0'
print(type(a))

 双引号也不影响,而且可以在单引号中包括双引号,让引号也作为字符串的内容存在

还有三引号引用

这里补充一个求字符串长度 len

a = ''''''''"""0.0"""''''''
print(type(a))
print(len(a))

 还有拼接字符串的操作

a = 'hello'
b = 'world'
print(a+b)

 注意:字符串不能和数字混合相加

布尔类型

a = True
b = False

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

 可以理解true就是1 false 就是 0 它主要用于逻辑判定

其它

它还可以有list,tuple,dict,或者等自定义类型

为什么要有这些类型?

           1.不同的类型,占用的内存空间不同,占用的字节不同

              int是4个字节 

              float固定八个字节

              bool一个字节

              str变长的

             2.不同类型,进行的操作也不同

               例如int和float是进行加减乘除的

               str可以加但不可以其他操作 可以用len进行操作 整型就不可以

动态类型特征

           指的是在程序运行的过程中,你改变一个变量的值也可以直接改变它的类型

a = 0
print(type(a))
a = '0'
print(type(a))

两面性

              对于中小型程序,可以打大大节约代码量

              对于大型程序,却提高了程序的交互成本,也降低了可读性

注释

注释是什么

           在编程中，注释是用于解释代码的功能、用途或实现细节的文字说明。

           注释对于代码的可读性和可维护性非常重要，因为它们可以帮助其他开发人员（或未来的自己）理解代码的工作原理和设计意图。

           注释在代码中以特定的语法标记，通常不会被编译器执行。根据编程语言的规范，注释可以有不同的形式。例如，在C和C++中，注释以“/”开始并以“/”结束；在Python中，注释以“#”符号开始。

           例如:

# 用来判断变量的类型和更改变量的类型
# 定义一个初始化变量
a = 0
# 检测出这个初始化变量是什么类型?
print(type(a))
# 改变这个变量的类型
a = '0' 
# 检测出这个初始化变量是什么类型?
print(type(a))

他并不会影响代码的运行,只是批注作用 ,可以提高可读性等

    作用        

1. 提供有关代码的背景信息：注释可以解释代码的用途、设计思路或历史背景。
2. 解释复杂或难以理解的代码段：对于难以理解的代码段，注释可以提供额外的上下文或解释其工作原理。
3. 记录代码更改：注释可以记录代码的修改历史、原因和日期，这对于跟踪代码的演变和了解代码库的状态非常有用。
4. 指导其他开发者：注释可以作为开发指南，指导其他开发者如何使用或修改代码。

 注释的语法

        在Python中，注释的语法有两种方式：

单行注释：使用井号（#）开头，后面跟着注释内容。例如：

# 这是一个单行注释  
print("这是一个单行注释")

多行注释：使用三引号（"""）或三单引号（'''）包裹注释内容。例如：

"""  
这是一个多行注释的例子。  
可以在多行注释中编写任意的内容。  
"""  
print("这是一个多行注释的例子")

       注意:不要把注释写到要注释的代码的下面,也不要写到要注释的代码的左边

注释的规范

     主要有以下几点  :

1. 清晰简洁：注释应该清晰、简洁地说明代码的功能和意图。避免冗长和复杂的注释，尽量保持注释的长度适中。
2. 解释代码逻辑：注释应该解释代码的逻辑和实现细节，帮助读者理解代码是如何工作的。
3. 避免不必要的注释：不要为了注释而注释，只有在必要时才添加注释。避免重复编写代码的注释，因为这会使代码变得难以阅读和维护。
4. 注释风格一致：在整个代码库中保持一致的注释风格。例如，选择单行注释还是多行注释，使用井号（#）还是三引号（"""）或三单引号（'''），都应该保持一致。
5. 适当使用中文注释：如果项目需要多人协作，建议适当使用中文注释，以便团队成员更好地理解代码。同时，也要注意保持注释的清晰和简洁。
6. 注释与代码同步：当代码发生变化时，相关的注释也应该进行相应的更新，保持注释与代码的同步。
7. 使用文档字符串（docstrings）：对于复杂的函数、类或模块，建议使用文档字符串来提供详细的说明和文档。文档字符串应该清晰地描述函数、类或模块的用途、参数、返回值和异常处理等信息。
8. 要文明注释: 不要弄乱七八糟带有负能量的注释.

输入输出 

 和用户交互

           程序与用户交互工程中

                   用户把信息传送给程序的过程是  输入

                   程序把结果展示给用户的过程是  输出

输入输出的最简单的方法是利用控制台

例如

  和

都是控制台,进行输入和输出的作用 

       但是: 我们常见的交互界面,例如QQ,浏览器,Wegame等,都不需要输入命令,大大简化了操作流程,用鼠标就可以操控,是属于图形化程序开发,拥有自己的的用户UI

通过控制台输出

Python使用print函数暑促到控制台

print('hello')

它能输出各种数字,字符串,还能输出其它类型的变量,基本能打印任何你想的东西

print(print('hello'))

 更多时候,我们都是输出数字加变量的东西

num = 0

print(f'num = {num}')

    注 意: 

num = 0

print(f'num = {num + 1}')

也是可以的,记住这种方法来打印变量加字符串,其中的f是格式化字符串,不做过多了解 

通过输入台输入

           可以利用input函数,丛控制台读取用户的输入

num = input('请输入整数')

print(f'你输入的整数是 = {num}')

            注意:

            input的参数相当于一个"提示信息",他的存在只是用于提示

            input的返回值结束用户输入的内容,是字符串类型

a = input('请输入第一个整数')
b = input('请输入第一个整数')
print(f'a + b = {a + b}')

    只是进行了字符串拼接,并不是算数运算,如果想进行算术运算,需要转换类型

   

a = input('请输入第一个整数')
b = input('请输入第一个整数')
a = int(a)
b = int(b)
print(f'a + b = {a + b}')

 运算符

算数运算符

           例如+ - * / % ** //的运算符,成为算数运算符

      1./是除法运算符,不能除0

      2.整数除小数结果是小数

      3.%是求余数而不是"百分数"

      4.**是乘方,小数和整数都能算次方

关系运算符 

例如 < <= >= == != 等运算符是关系运算符,他们在比较操作数之间的关系

       其中特殊的是:

                             == 是 等于

                             !=  是 不等于

                             其它的就是正常的符合数学判断

                           

在判断过程中,如何关系符合,会返回Ture(1),如果关系不符合则表达式返回False(0)

a = 1

b = 2

print(a > b)

print(a < b)

关系运算符还能对字符串进行比较

a = 'one'

b = 'tow'

print(a > b)

print(a < b)

print(a == b)

      这玩意的比较规则,是首字母开始往后排序,在字典中字母越靠前比出的结果越小,但是对中文比较没意义的

      注意:使用==去判断浮点数的关系存在一定的风险,因为浮点数有误差,进行计算时误差会变大

print(0.1+0.1 == 0.2)

 因为这个玩意计算出来是0.200000000004 所以出现了flase

所以它的比较方式是

a = 0.1 + 0.1

b = 0.2

print( -0.000001 <(a - b)<0.000001  )

逻辑运算符 

          逻辑运算符主要有三个and or not

                  and 并且 若两操作数仅为True 则结果为True 否则为False (一假全假)

                  or    或者 若两操作数均为False 最终结果为 False 否则为True (一真全真)

                  not  逻辑取反 若操作数为True 结果取False,若为False 则取True (颠倒是非)

a = 1

b = 2

c = 3

print(a < b and a < c)

print(a > b or a > c)

print(not (a < b and a < c))

          注意:短路求值

                  对于and操作来说,如果左侧出现了False 那么就全false 不会关注右操作符

                  对于 or 操作来说,如果左侧出现了 True 那么全是 True 不会关注右操作符

 赋值运算符

        · =

= 表示赋值,注意和==区分即可

= 可以链式赋值和多元赋值

链式赋值

a = b = 10

           tip:不建议使用 

多元赋值

 a , b = 10 , 20

 这个是a = 10,b = 20 

       ·复合赋值运算符

        例如+= -= *= /= %=

        他们只是整合了运算符 比如 a += b 就是 a = a + b 以此类推

a = 1

a = a + 1

print(a)

b = 1

b += 1

print(b)

        其它

                      有身份运算 成员运算 位运算 在此处咱是不介绍

小结 

          至此我们学完了python的语法基础的一部分

          学习了常量 变量 注释 输入输出 运算符的最简单的部分

          稍后我将继续更新(依然是先出各个部分然后整合成大块的文章)

          谢谢! 

   

 

顺序语句

            python的代码是从上往下依次执行的

print('1')
print('2')
print('3')

 条件语句

            例如:按照"如果,则"的逻辑判定后按顺序触发

            条件语句也叫做分支语句

语法格式

           例如if else关键字表示的条件语句

event = 1

if event:

   print("结果作为真")

else:

   print("结果为假")

      注意  " : "  的存在 

      这里解释 event 为 真(不是0)的时候 执行第一个 否则 结果为假

还有 if - elif - else

event1 = 1
event2 = 1
if event1:
    print(event1)
elif event2:
    print(event2)
else:
    print(event1)

 如果event1是真 则执行print(event1)

 如果event1是假 且 evnet2 是真 则执行 print(event2)

 如果event1是假 且 event2 是假 则执行else内容

注意 if后面没有()并且以:作为结尾

        它后面的语句区块是以 缩进(一个tab或者四个空格)来判定的 (类似于{},但他不用)

        多分支语句是else if的缩写 elif

   我举一个栗子

scanf = input("输入1为真,输入0为假")
scanf = int(scanf)
if scanf:
    print(f"你输的是{scanf}是真")
else:
    print(f"你输的是{scanf}是假")

这个是转换为数字的结果

还有不转换的版本就是以字符串的形式对待

scanf = input("输入1为真")
if scanf == '1':
    print(f"你输的是{scanf}是真")
else:
    print(f"你输的是{scanf}是假")

 缩进和代码块

            代码块是放在一起执行的代码,在python缩进往往代表了代码块,相同缩进代表了一整个代码块,还有分级缩进进行代码嵌套

scanf = input()

if scanf == '1':

        print('hello')

        print('hello again')

 scanf = input()

if scanf == '1':

        print('hello')

print('不管你输入的是不是1,我这个hello的都要给你hello一下')

上述代码中 第一个代码执行的两个print是一个代码块 第二个代码的两个print不是一个代码块

此外,还有嵌套代码

scanf1 = input()

scanf2 = input()

if scanf1 == '1':

        if scanf2 == '1':

                print('你输入两个1')

        print('我知道你的scanf1是1')

print('我在嵌套之外')

这里的二级条件就是scanf2的情况,第二个print和第二个if是同缩进,他俩是一个代码块

不能平白无故的缩进

空语句pass

pass表示空语句,不会滴程序执行有任何影响,只是占个位

例如

a = 1

if a != 1:

        pass

else

        print('hello')

如果把pass哪一行改为空行,程序会报错

循环语句

while循环

格式

while 条件:

        语法块

条件为真循环 条件为假不循环了

eg:打印1-10

count = 0
while count < 10:
    count += 1
    print(count)
print('打印结束')

 for循环

语法格式

for 循环变量 in 迭代对象:

        循环体

python的for循环没有初始化语句,循环判定合格语句,循环更新语句

迭代对象计就是内部包含多个元素能一个个取出来的变量

例如

打印1-10

 for i in range(1,11):

        print(i)

打印2,4,6,8

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

        print(i) 

注意 range函数是 range(初始范围,结束范围,步长) 例如 (1,11) 是从[1,10] 且步长为1 

打印10-1

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

        print(i)

continue 和 break 

        continue是立即结束此次循环,进入下一次循环

        break是跳出循环

for i in range(1,6,1):

        if i == 2:

                continue        

        print(f'数字{i})

for i in range(1,6,1):
    if i == 2:
        break
    print(f'数字{i}')

函数

函数是什么

        编程中的函数可认为时一段被重复使用的代码片段

        在编程过程中,我们会多次使用类似或者相同的代码组合,此时我们可以选择把我们重复使用的代码提取出来作成一个函数

语法格式

创建函数/定义函数

def 函数名字(形参)

        函数体

        return 返回值

调用函数

函数名(参数)

返回值 = 函数名(参数)

        注意:函数的定义并不会执行函数体内容,不许调用了函数体才会执行,调用几次就执行几次

                函数必须先定义(声明)再使用

def calcSum(beg,end):
    thesum = 0
    for i in range(beg,end+1):
        thesum += i
    print(thesum)

#求1-100的和
calcSum(1,100)

         注意:python中更支持小写的代码格式,大写代码会警告

                 再自定义函数下面尽量有两个空行  //遵循的PEP8编程规范 是个软性规则

函数参数

                再自定义函数的时候,再自定义函数后面的()中制定"形式参数"(简称形参),然后再调用的时候,有调用者把"实际参数"产地进去.

def calcSum(beg,end):
    thesum = 0
    for i in range(beg,end+1):
        thesum += i
    print(thesum)

其中的beg and 就是带进去的函数参数

                注意:你传入的参数只要符合在自定义函数内的操作,就不会出问题不报错

函数的返回值

        自定义函数可以自定义返回什么 用 return返回想要 然后可以赋值类的

def add(x,y):
    c = x + y
    return c


l = add(1,2)
print(l)

        这个代码就是辅助返回了个c的值 然后c的值给了l

        有一个通用的编程原则,是一个代码只做一件事,写功能单一的代码,不进行复杂的处理,可以提高代码的可维护性(逻辑与界面分离)

         一个函数中可以有多个返回规则

        利用条件语句调用return

def onortow(x):
    if(x % 2 != 0):
        return "奇数"
    else:
        return "偶数"

         注意:一旦执行到return 就会跳出函数了

         ptyhon可以返回多个值

def whereareyou():
    x = 5
    y = 1
    return x,y


x,y = whereareyou()
print(x,y)

        同时,如果不需要x或者y的某一个返回值,可以用"_"来占位

变量的作用域 

        例如:

def whereareyou():
    x = 5
    y = 1
    return x,y


x,y = whereareyou()
print(x,y)

                 这个代码中 函数内部有x y 函数外部也有x y 但是他们的作用域不同

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

        上面那个代码中,x y只在whereareyou()函数中生效,一旦离开了函数的范围,这两个变量也就不再生效了

# 返回坐标
def whereareyou():
    x = 5
    y = 1
    return x,y


whereareyou()
print(x,y)

 

会说x未被定义

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

def whereareyou():
    x = 5
    y = 1
    return x,y


x,y = whereareyou()
print(x,y)

在这个代码中 就允许了x y 在函数内外同时存在 ,它们只是变量名相同,但不是同一个变量

        内部的是局部变量 外面的是全局变量

        但是函数里也可以使用全局变量

x = 0

def printf():
    print(x)


printf()

 如果要修改全局变量 需要用到global

x = 0

def printf():
    global x
    x = 1


printf()
print(x)

 函数的执行过程

        函数的执行过程是在全局中逐条进行,进入到函数后在函数内逐条进行,结束后回到全局变量跳入函数的位置继续向下进行

def text():
    print("执行一下子")


print("第1次执行")
text()
print("第2次执行")
text()
print("第3次执行")
text()

 链式调用 与 嵌套调用

其实也就是让代码更集中,减少写代码的行数

def text():
    print("执行一下子")
    return "0"


print(text())

其中的 print(text())是链式调用 调用print的同时调用了text进入内函数 

在text()中又调用print就是嵌套调用,函数内调用函数

      提一下函数栈帧,每个自定义函数在调用的时候就会栈帧,结束后会立马消亡不占用内存

函数递归

         递归就是在函数中 自己调用自己

例子:计算n的阶乘

def event(n):
    if n == 1:
        return 1
    else:
        return n * event(n-1)


x = 5
n = event(x)
print(n)

结果是120  在这个代码中 event就调用了event

        注意:函数递归要注意

                存在递归的结束条件,否则会栈溢出

                每次递归都要接近结束条件

        反例子

def event(n):
     return n * event(n-1)


x = 5
n = event(x)
print(n)

        没有而结束条件就报错溢出了 

                注意:递归代码一般都是可以转换成等价的循环代码的,可以用迭代的方式写代码,来加快运行速度,但是递归在一些本身就是通过递归的方式定义的东西的时候,会更方便和更容易理解,大部分时间建议用迭代而不是递归

参数默认值

                python 中的函数,可以给形参制定默认值

                带有默认值的参数,可以在调用的时候不传参

def add(x,y,debug=False):
    if debug:
        print(f'打印x={x} y={y}')
    return x+y


print(add(1,1))
print(add(1,1,True))

在这个代码中 给debug初始化定义为False 如果不给debug传参,那么debug就是False,如果传了True才会传

        注意:如果传值不对依然会报错 

 其次还要求带有默认值的形参,需要在形参列表的后面~~

而不能在前面或者是中间!,不然依然会报错

 关键字参数

                一般在带哦用的时候需要给函数制定参数,按照自定义函数的参数定义的顺序来填写,但是我们可以通过关键字参数来调整传参顺序

def add(x,y):
    print(f'打印x={x} y={y}')


add(1,2)
add(y=1,x=2)

这样就可以按照自己想给的顺序传参,不必在乎原来的顺序 

 列表和元组

列表和元组分别是什么

列表是一种在代码中批量表示和保存数据的方法,元组相似于列表,但是列表中存放的元素可以修改调整,元组中存放的元素是创建元组的时候就设定更好的,不能修改调整.

        也就是用一个变量来表示多个数据,类似于其他编程语言中的"数组"

创建列表

        创建列表主要有两种方式,例如[  ]表示创建一个空的列表

alist = [ ]
alist = list()
print(type(alist))

        如果是要往里面设置初始值,可以直接在[ ]中写

alist = [1, 2, 3, 1, 2, 3]
print(alist)

         而且在这个列表中可以防止不同类型的玩意

alist = [1, "2", True]
print(alist)

访问下标

        访问下标的目的是取出列表中的元素 它的下标访问运算符也是[ ](下标初始也是0)

alist = [1, "2", True]
print(alist[0])

         通过下标访问来修改列表元素

alist = [1, "2", True]
alist[1] = "啦啦啦"
print(alist[1])

        注意 在这种情况下,可以有-1的存在 也就是alist[-1] 这个-1等价len(a)-1 (也可以认为是倒数的第几个元素)

alist = [1, "2", True]
print(alist[-1])
print(alist[len(alist) - 1])

 切片操作

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

            也就是使用[ : ]的方式进行切片

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

        在 [1,3)的范围内打印取不到3 

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

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

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

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
print(alist[::2])

 步长也可以是负的,是反向打印

遍历列表元素

"遍历"是把元素全取出来,再分别进行处理

        例如用for循环

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
for i in alist:
    print(i)

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

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
for i in range(0,len(alist)):
    print(i)
    print(alist[i])

        也可以用while循环,控制下标

i = 0
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
while i < len(alist):
    print(alist[i])
    i += 1

新增元素 

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

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

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

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

查找元素

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

alist = [1, 2, 3, 4]
print(2 in alist)
print(5 in alist)

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

alist = [1, 2, 3, 4]
print(alist.index(1))
print(alist.index(4))

如果报错,比如查找5 

 

 删除元素

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

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

        或者按照下标用pop选择性删除

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

        或者按照remove的方法,按照你好值删除元素 

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

 列表连接

        使用+直接连接

arr = [1, 2, 3]
brr = [4, 5, 6]
crr = arr + brr
print(crr)

        使用 extend 方法把一个列表拼接在另一个列表的末端

arr = [1, 2, 3]
brr = [4, 5, 6]
arr.extend(brr)
print(arr)
print(brr)

元组

        元组与列表来说,在功能上是一致的,元组使用()来表示

arr = (1, 2, 3)
print(arr)

        元组不能修改内部元素,列表可以修改

        其次,元组算一个集合类型

def getpoint():
    return 0, 1


event = getpoint()
print(type(event))

元组只是不可更改,大部分操作和列表相同 

为什么要有元组?

                首先元组内容不可变

                元组再字典中有用

字典 

字典是什么

        字典是一种存储键值对的结构

        键值对是 键(key) 和 值(value) 进行一个一对一的映射,然后就可以根据key快速找到value

创建字典

        创建一份空字典,用{ }表示字典

a = { }
b = dict()

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

        也可以创建字典的同时给初始值

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

        使用print打印字典内容

a = {'level': 7, 'name': '芜湖'}
print(a)

其中 key是 'level' 对应的value 是 7 

 查找key

        使用 in 可以判定key是否存在 字典 中存在 并返回布尔类型

a = {
    'level': 7,
    'name': '芜湖'
}
print('level' in a)
print('leve' in a)

        使用[ ]通过类似于取下标的方式,获取元素的值,只不过此处的下标是key(各种类型)

a = {
    'level': 7,
    'name': '芜湖'
}
print(a['level'])
print(a['name'])

        如果在字典中没有key 就是出现异常....(我没key 我没key)

a = {
    'level': 7,
    'name': '芜湖'
}
print(a['leve'])

新增或修改元素 

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

        如果key不存在,对取下标操作赋值,就是新增键值对

a = {
    'level': 7,
    'name': '芜湖'
}
print(a)
a['age'] = 88
print(a['age'])

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

a = {
    'level': 7,
    'name': '芜湖'
}
print(a)
a['level'] = 88
print(a['level'])

删除元素

        使用pop方法根据key删除对应键位

a = {
    'level': 7,
    'name': '芜湖'
}
print(a)
a.pop('level')
print(a)

遍历字典元素 

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

a = {
    'level': 7,
    'name': '芜湖'
}

for key in a:
    print(key, a[key])

取出所有的key和value 

        取key 用keys

a = {
    'level': 7,
    'name': '芜湖'
}

print(a.keys())

        取valeu用values

a = {
    'level': 7,
    'name': '芜湖'
}

print(a.values())

        items可以获取所有的key和value

a = {
    'level': 7,
    'name': '芜湖'
}

print(a.items())

合法的key类型 

         不是所有类型都可以作为字典的key

        字典本质上是哈希表,也就是只有符合哈希表规则的东西才可以作为key

                可以使用hash对象计算某个对象的哈希值

                但凡能计算出哈希值的类型,都可以作为字典的key.

print(hash(0))
print(hash(77.5))
print(hash('age'))
print(hash(True))

        列表 元组 字典 都无法计算哈希值

print(hash({}))
print(hash([]))
print(hash(()))

文件 

文件是什么

        变量是数据在内存中,重启关机就会消失

        文件存储在硬盘中,即使关机重启也不会小时

        文件有很多类型,例如txt exe mov mp4等

文件路径

        经常用电脑的都知道,在硬盘中,为了找到想要的文件,往往需要按照一定的顺序打开(目录)文件夹查找,为了确定文件的位置,我们用路径来形容

这就算一个路径

        而且每个文件的路径是唯一的

        而且目录名之间用 \ 或者 / 来分隔的

 打开文件

        使用内建函数open来打开

f = open("F:/1.txt", 'w')

        注意

                第一个参数是第一个字符串,也就是要打开的文件路径

                第二个参数是一个字符串,表示打开方式,其中  r表示读  w表示写 a表示追加写

                如果打开文件成功,返回一个文件对象,后宣布的读写文件曹祖都是围绕这个文件对象展开

                如果没有就会报错 说 FileNotFoundError

关闭文件

        使用close的方法关闭已经打开的文件

f.close()

使用完文件要及时关闭 而且一个程序能打开的文件个数是存在上线的 

f = open('F:/1.txt', 'w')
f.close()

flist = []
count = 0
while True:
    f = open('F:/1.txt', 'w')
    flist.append(f)
    count += 1
    print(count)

 

当打开8189(其实是8192个文件)个文件的时候 ,说打开了太多文件了

所以要及时关闭文件

写文件 

        文件打开之后就可以写文件了

        要写文件就需要open.w

        使用write方法写入文件

f = open('F:/1.txt', 'w')
f.write('hello')
f.close()

 

         但如果打开方式有错误,就会报错

f = open('F:/1.txt', 'r')
f.write('hello')
f.close()

         但是每次使用w都会清空原有数据

        可以使用'a'实现追加写 此时会存在文件中

f = open('F:/1.txt', 'a')
f.write('hello')
f.close()

读文件 

读文件需要用r的方式打开文件

使用read的方式万层操作

f = open('F:/1.txt', 'r')
whatread = f.read(9)
print(whatread)
f.close()

 

 

如果是多行代码也可以循环读取

 

f = open('F:/1.txt', 'r')
for line in f:
    print(f'line={line}')
f.close()

        注意,如果想使用中文,要加额外的东西

f = open('F:/1.txt', 'r',encoding='utf8')

        想让每次打印没有空行要加

   print(f'line={line}', end='')

还可以通过readlines之间打印全部内容

f = open('F:/1.txt', 'r', encoding='utf8')
lines = f.readlines()
print(lines)
f.close()

 

 

上下文管理器

是防止文件忘记关闭的东西

def func():
    with open('f:/1.txt', 'r', encoding='utf8') as f:
        if True:
            return 0

这个是当with执行的代码块结束 就会自动执行f文件的关闭