我在VScode学Python（Python的基本了解，数据类型，控制语句，文件File）

开始学习Python了

前言

Python的介绍：

1）语言的发展：

解释型语言:通过专门的解释器，根据需要可以将部分或全部源代码转换成特定平台（Windos、Linux、macOS等）的机器码。
优点：跨平台性好，通过不同的解释器，将相同的源代码解释成不同平台下的机器码。
缺点：一边执行一边转换，效率较低。

是完全面向对象的语言，解释性的语言。可以通过C/C++调用的语言本身也是由诸多其他语言发展而来包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。

2）特点：

软件开发更加快速和令人愉快。

简洁性、易读性以及可扩展性。易读、易维护、速度较快。
现有的版本Py3和Py2
Python 是完全面向对象的语言，具有简洁、 易读、可扩展、可嵌入的特点，其函数、模块、 数字、字符串等都为对象，支持继承、重载、派生、多继承、重载运算符、动态类型。使用 Python 可将 其他语言编写的程序进行集成和封装，以此来编写扩充模块。
Python 语言与其他编程语言相比，Python 依赖缩进，使用空格来定义范围，如循环、函数
和类的范围，而其他编程语言通常使用花括号来实现上述目标，如 C、C++等语言;另外， Python 使用新行来完成命令，而不是使用分号或括号。在 Python 中，一个模块的界限，是由每行的首字符在这一行的位置来决定的，而C语言与字符的位置没有关系，是用一对花括号{}来明确地定出模块的边界。

缺点：

1. 运行速度慢。2) 代码加密困难

在VScode 配置：

相似的与上回Java的vscode配置，这次来配置Python的配置，将我们的集成开发的code做大做强再创辉煌。

安装Vscode：

下载VSCode

鼠标滑到下面，找到这个点进去

下载Python

装扩展

来源：
下载上方的链接

在cmd中检测Python的存在

直接呼唤他：

代码简单写一个：

print("3")

print ("Hello My write_Python!")

Python的用处：

Web应用开发、自动化、人工智能、爬虫。
应用领域从系统管理、网站开发、手机脚本编制、教育到硬件测试、投资分析、计算机游戏和航天器控制。

Python 被部署在各种各样的产品和角色中。其目前的用户群包括谷歌、 YouTube、 Industrial Light & Magic、 ESRI、 BitTorrent 文件共享系统、 NASA 的喷气推进实验室、游戏 Eve Online 和国家气象局。

首先创建一个后缀带有.py的文件。

这个不像java语言的public必须名字和文件名称是一样的。在Python里文件名称命名与本身无关（但一定要合理，要切合内容，关于文件本身的内容）

输入代码：

print ("Hello My write_Python!")

第一节：基本了解：

Python的输入与输出

input（）函数输入【获取键盘输入的字符串】

Python以字符串的形式来处理用户输入的内容。可以包含任何字符。【不论输入什么都是字符串，要类型需自行手动转换】

str = input(user_data)

例子：

a=input("Hello_PythonWorld)

input(提示信息)，用以在用户输入内容之前显示提示信息。

无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型

print（）函数输出

方法原型：

print (value,...,sep='',end='\n',file=sys.stdout,flush=False)

当我们指定了 end＝""， print() 语句的输出都不会换行。
print() 函数的 flush 参数用于控制输出缓存，该参数一般保持为 False 即可，这样保持较好的性能。

Python缓冲

“python缓冲为提高程序执行的效率服务的实际上就是在python解释器启动时从内存空间中开辟出一小部分用来存储高频使用的数据。
这样可以大大减少高频使用的数据创建时申请内存和销毁时撤销内存的开销

Python缩进规则:

赋值语句要同一竖列；
首行不缩

Python3关键字（35个）

     和C语言相同的是       变量名不得与关键字名称相同

输入：

help("keywords")

Python变量

name = value

标识符中的字母是严格区分大小写的。如果大小格式不一样，代表的意义也是完全不同的。完全独立、毫无关系的，它们彼此之间是相互独立的个体。

<1>注意

在 Python中变量名称区分大小写，变量命名需要一定的规则。

●变量名必须以字母或下划线字符开头。只能包含字母、数字字符和下划线【A-Z、a-z、0-9】
【变量名称不能以数字开头。】（这个和C语言是相似的）
●变量名称区分大小写(如 day、Day、DAY就是分别是3个不同的变量)。
●变量名不得与关键字名称相同

在 Python 中没有声明变量的命令，不需要提前使用任何特定类型进行变量类型声明，最先变量赋值时，才会根据赋值的类型为变量创建类型，同时，也可以在设置后更改变量类型。变量创建及类型依然可以更改。

解释：1）没有声明变量的命令：
不需要去声明数据类型这是由它的解释性和动态语言的特性决定的。 程序在运行的过程之中去动态的判断赋值给这个变量的数据是什么

等号（=）用来给变量赋值。运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
Python的内置数据类型

• 数值类型：int ，float，complex
• 文本类型：str
• 布尔类型：bool
• 二进制类型：bytes,bytearry,memoryview,
• 序列类型：list，tuple,range
• 集合类型：set,frozenset
• 映射类型：dict

续 1)

Python 是弱类型的语言

除了Python语言外还有 php，JavaScript语言属于弱类型语言·

弱类型是说在书写代码时不用刻意关注类型，但是在编程语言的内部仍然是有类型的。我们可以使用 type() 内置函数类检测某个变量或者表达式的类型。

#Python 是弱类型的语言
x=123
x="My_writePy3"

弱类型语言有两个特点：
(1)变量无须声明就可以直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。
(2)变量的数据类型可以随时改变，比如，同一个变量可以一会儿被赋值为整数，一会儿被赋值为字符串。

结果如下：很好的论证了，在设置后更改变量类型，创建及类型更改

当我们在使用弱类型的语言要格外的注意变量的使用，防止变量变换错误导致的程序的崩溃。

<2>命名规则：

注意：

使用内置函数的名字作为标识符使用（例如变量名、函数名、类名、模板名、对象名等），虽然这样Python 的解释器不会报错，但这会导致同名的内置函数被覆盖，从而无法使用。（这）

(1）匈牙利命名法：

属性+类型+对象描述【直观的了解对象是什么】。

(2）驼峰命名法：

分为大小驼峰命名法

【1】大驼峰命名法：

串联起来的单词的首字母都要大写。MyWritePython

【2】小驼峰命名法

串联起来的单词的除了第一个首字母都要大写。myWritePython

(3) Guido推荐在Python中使用的

本图来源于网络查到的《Python网络爬虫实战》一书

（4）注意事项：应避免使用以下划线开头的标识符。

以单下划线开头的标识符（如 _width），表示不能直接访问的类属性，其无法通过 from...import* 的方式导入；
以双下划线开头的标识符（如__add）表示类的私有成员；
以双下划线作为开头和结尾的标识符（如 __init__），是专用标识符。
因此，除非特定场景需要，应避免使用以下划线开头的标识符。
我们应尽量避免使用汉字作为标识符，

<3>多个变量的赋值

a, b, c = 1, 2, "hello My_python"

Python常量

Python没有严格的常量。

• 整数常量
• 字符串常量
• 浮点常量
• 布尔常量

My_python = 5201314
print(My_python)

等等此类的常量。

Python注释

有三种 分为两大类：单行注释和多行注释

《1》单行注释
以 # 开头：
# 我真的真的真的就是一个注释print("My_python!")
《2》多行注释
（1）三个单引号 ‘’’
‘’’
我真的真的真的就是一个注释
我真的真的真的就是一个注释
我真的真的真的就是一个注释
‘’’
（2）三个双引号 “”"
“”"
还是我–注释
还是我–注释
还是我–注释
“”"

取消print的自动换行

加上end=“ ”

运算符

Python可以支持 算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符、身份运算符

<1>Python算术运算符

加；减；乘；除；整除；取余；指数

• ； - ； * ；/ ; // ; % ; **

wd=2
b=7
print("wd+b=",wd+b)
print("wd-b=",wd-b)
print("wd*b=",wd*b)
print("wd/b=",wd/b)
print("wd//b=",wd//b)#整除  向下取整
print("wd%b=",wd%b)
print("wd**b=",wd**b)##wd的b次幂

<2>Python比较运算符

== ； != ; > ；< : >= ； <=

<3>Python赋值运算符

== += -= *= /= %= **= //=

a=1
b=2
c=a+b
print(c)
c+=a
print(c)
c-=b
print(c)
c*=b
print(c)
c/=a
print(c)
c=40
c%b
print(c)
c**=2
print(c)
c//=3
print(c)

<4>Python位运算【二进制】

&—相同为1 ，可以用【x&1】于判断是不是奇数【比%2的好】
|—二个二进位有一个为1
^----异或操作符 同相反
~----取反
<<—左移
.>>–右移

<5>Python逻辑运算符【布尔】

与-and 或-or 非-not
(x and y)

布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。
布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

<6>Python三目运算符

Python中没有像C语言/C++里面直接给定的三目运算符。但我们可以利用关键字创造一个‘伪三目’
【值得一提的是在C语言中三目运算符就是if—else的一种变种】

max = a if a>b else b

<7>Python海象运算符 :=【Py 3.8版本引入】

# 传统写法
if (result := some_function()) is not None:
    # 使用result做一些操作
else:
    # 处理函数返回None的情况

# 使用海象运算符
if result := some_function():
    # 使用result做一些操作
else:
    # 处理函数返回None的情况

海象运算符（walrus operator）:= 是一种在 Python 3.8 中引入的赋值表达式，
它允许将**表达式**的结果赋值给变量，并且返回该结果。

例如，可以使用x := len("hello")表达式来将字符串 “hello” 的长度赋值给变量 x，并且该表达式的结果将是 5。

具体来说，:=运算符允许我们在表达式中创建并赋值变量，而无需单独一行使用赋值语句。例如，我们可以在条件语句中使用海象运算符来检查变量的值，并根据需要执行操作，

避免以下的特殊情况：

因为在这个代码中，海象运算符 := 的作用是将变量 x 赋值为 10，然后将 x 的值作为条件表达式进行判断。由于 x 被赋值为 10，所以条件表达式的值为 True，因此输出的结果是 x不等于10。如果将 x 的值改为其他值，输出结果仍然是 x不等于10，因为条件表达式的值始终为 True

x = 5
if x := 10:
    print("x不等于10")
else:
    print("x等于10")

<8>@= 矩阵乘法

import numpy as np
A = np.array([
    [1,2],
    [3,4]
])

B = np.array([
    [1,2],
    [3,4]
])

A =A @ B
print(A)
#或者，用这个方法
C = np.dot(A, B)
print(C)

注意事项：

注意事项

1. 海象运算符只能在 Python 3.8 及以上版本中使用，低于该版本的 Python 不支持。

2. 海象运算符的语法是 :=，其中冒号和等号之间不能有空格。

3. 在一个赋值表达式中，变量名必须放在赋值符号的左侧，而表达式必须放在赋值符号的右侧。

4. 在使用海象运算符时，需要小心避免出现副作用，因为它可能会导致代码难以阅读和调试。

5. 在处理可迭代对象时，使用海象运算符可以提高代码的性能和可读性。但是在使用海象运算符时，应该始终确保变量的值已经存在，否则会引发NameError
   错误。

6. 在使用海象运算符时，要避免过度使用它，因为它可能会使代码变得更加复杂和难以理解。

‘%’格式化输出

这里是将数字 转换成了 字符串哦

print (" %s is %d !!!" % ('Python', 666))

a=5
print("%d"% a)

指定最小输出宽度:

%10d 表示输出的整数宽度至少为 10；
%20s 表示输出的字符串宽度至少为 20。

精度%m.nf

握快速字符串格式化

语法:f内容(变量]"
不理会类型
不做精度控制，适合对精度没有要求的时候快速使用

注意事项：

以错误学习：

错误代码：

  print("%d * %d = %d" % i, %j, %i*j,end=' ')，为什么不能这样%一一对应，而是只能用一个%

错误原因：

在Python中，字符串格式化操作符%只能使用一次，并且后面的参数需要以元组的形式传递。
print("%d * %d = %d" % (i, j, i*j), end=' ')·

格式化输出’%‘和快速输出’ f '和不写格式化三者对比：

格式化输出’%’

a=5
print("%d"% a)

快速输出’ f '对比：

握快速字符串格式化
语法:f内容(变量]"

不写格式化

用逗号隔开

代码

i=1
while i<=9:
    j=1
    while j<=i:
        # print(f"{(j)} * {(i)}={(j*i)}",end=' ')
        # print("%d * %d = %d" % (i, j, i*j),end=' ')
        print(i,'*',j,'=',i*j,end=' ')
        j+=1
    i+=1
    print()

*第二节：Python的数据类型；

基本的数据类型*

• 数字类型：Py3支持int、float、bool、complex（复数）。
• 字符串类型：用单引号 ’ 或双引号 "引起来的

复合的数据类型*

• 列表类型
• 元组类型
• 集合类型
• 字典类型
  

一、数字类型（Number）：

相较于C语言/C++来说Python是及其的方便，在C语言/C++中大部分的类型需要自己去定义

int a=10;
float  c=20.3;
bool d=True

学习某个类型就要了解某个类型具备什么样的条件

<1>【数字类型的判断】

函数type(x),返回x的类型，用于所以类型判断

<2>【整数 int】

使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。

Python中是没有long /long long 这样开辟大空间的是数据类型的，理论上只要空间够大，就能算出来，你需要算的。

[进制]

	使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。
 number = 0xAF # 十六进制    以0X 0x开头的
 number=0o77 # 八进制       以0O  0o开头的
 number=0b11 #二进制       以 0B   0b开头的

<3>【浮点数 float】

cs   = 1000.0  
print (cs)

在科学计数法中，为了使公式简便，可以用带 “E” 的格式表示【E“ 是 exponent(指数) 的缩写。】
是双精度的。对于很大或者很小的浮点型，可以使用科学计数法【以10为基础】表示。

[书写形式]

（1）十进制形式：平时看到的身高体重之类的。
（2）指数形式：aEn 或 aen 整个表达式等价于数学上的a*10^n

x=0.00000000000000000000000000007  
print("x=",x)                     # x=7e -27
print(type(x))   				 #<class ='float'>

[精度问题]

Python的默认浮点数是双精度。不过不论是什么精度，浮点数在计算机中都是以二进制保存。
出现在方程的根十分巨大的情况下【有一些类似于求某一点的切点的斜率】

<4>【布尔类型 bool】

在Python3 中，bool 是 int 的子类，True 和 False 是可以和数字相加。 True=1、False=0
判断对错常用。在C语言中可以用0和1标记、C++中可以直接使用Ture or False这两个标记。

<5>【复数 a + bj / complex(a,b)】

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

<6>（数据类型转换）：

这一点与C语言是相似的。也有着一定的区别：
在C语言中是数据类型加上括号，而Python是需要转换的数值加上括号

这里是引用

int（1.23）=1    #去除小数部分
float(2)=2.0    #增设小数部分
complex（5）=5+0j   

math库

既然学了数字类型了，那必然离不开我们从小到大常常学的数学。

概述

math 内置的数学类库，返回值均为浮点数，不支持复数；如果计算复数，使用 cmath。
（5个数学常数 53个函数方法）

【引用】

(1)【法一】利用保留字import引用库：

import使一个变量名引用整个模块对象，因此必须通过模块名称来得到该模块的属性

对于math库里面使用 math.(函数名）的形式
vscode:

IDLE:

(2)【法二】from math import (函数名）：

     **from   math   import   (函数名），（函数名）**【这样可以引用多个】

如果使用from导入变量，变量和作用域中现有变量重名，变量就会被悄悄的覆盖掉
若仅仅使用少量的函数方法，推荐使用这一项（我认为和C语言中的#include引用很像，只需要写对对应的函数即可）

Vsocde：

IDLE：

(3)好用的方法：from math（模块名称） import * 【表示导入这个库里面很多方法】

像这样的最好只引用一次

from math import *
print(pow(2,3))
print(ceil(.666))

【常数----五个函数常数】

import
print (math.e)     #2.718281828459045
print (math.inf)    #inf      #无穷大    #若是print (-math.inf)  结果就是  -inf
print (math.pi)     #望名生义我们最多用到的π     #3.141592653589793
print (math.nan)    #nan      <class 'float'>  类型检查用type(需要检查的值或者函数）
print (math.tau)   #6.283185307179586    就是2*π的值

二、序列类型

分为 字符串 “str”、列表[list]、元祖（tuple）

序列索引

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0。与字符串相同的是：
正向递增的序号是【0，number.size-1】;
反向递减的序号是【-number.size， -1】；

支持的函数：

type(x)–查看类型；
len(x)–计算序列长度；
min(x)–序列x中最小值
max(x)–序列x中最大值
in/not in --成员操作符；（检测某元素¹是否为序列的成员）
s.count(x)–序列s中x出现的次数
凭借’+’ 连接两个相同类型，它会将两个序列进行连接，但不会去除重复的元素。
指的是“+”运算符的两侧序列要么都是列表类型，要么都是元组类型，要么都是字符串。
凭借 ‘*’ 多次输出这个类型内指定的内容
s*n或者n*s
凭借 方括号 ‘[ ]’ 索引获取元素
凭借 ’ [ : ] ’ 截取字符串中的一部分 >） s[i:j]-->返回包含序列 s 第i到j个元素的子序列 (不包含第j个元素） s[start : end : step]-->步骤分片，返回包含序列s 第i到j元素以k为步长的子序列
str()–> 将序列转换为字符串.
list()–> 将序列转换为列表。
sum()–> 计算元素和。
sorted()–> 对元素进行排序。
reversed()–> 反向序列中的元素
sort
sorted可以对其他数据

Pow 和** 的区别：

若都是两个整数的话【底数和指数】
pow是浮点型 所以出来会是小数
**就是整数

一、字符串类型–>（复合数据类型、序列类型，不可被修改rep）：

通常，在 Python 中使用 str 对象处理文本数据，str对象也称为字符串。字符串(string)是由单引号()或双引号(“)或三重单引号(”)括起来的文本信息组成的有序字符集合。三重引号不同之处在于，使用三重引号的字符串可以跨越多行，其中所有的空白字符都将包含在该字符串中。由于不存在单独的字符类型，原有的字符表示，如’a’，在 Python 中表示长度为 1的字符串，它和"a"表示相同的字符串。

依旧是使用type（）函数检测是什么样的类型

经过上图我们可以知道的是在Python中
（1）无论是双引号（“”）还是单引号（‘’）都起到同样的作用，能够括起来单个字符和多个字符。
（2）Python中字符串可以单独存在也可以存放在某一给定的变量中。
（3）在Python中可以修改变量的类型且不用强转。

<1>len

获取字符串长度

<2>字符串运算符

Python 不支持单字符类型，使用引号( ’ 或 " )来创建字符串，单字符在 Python 中也是作为一个字符串使用。

（1）凭借’+’ 连接两个字符串（连接字符串变量或字符串字面量//无法和非字符串类型进行拼接）

a='hello'
b="My_py"
print(a+b)
print((a+b)+' '+(a+b))
#可以来接很多次
print("这是我打的a+b的最终"+ a+ ' '+b)
print("这是我打的a+b的最终  "+ a+ ' '+b)
#注意引号“ ”中的空格，在引号外可以来接很多次

（2）凭借 ‘*’ 多次输出某一字符串

将本身字符串多次拼接重复连接而成的

x="py " print(x*3)

将字符串中的字符’o以列表的形式输出

代码

s2='wo are  wo wo students' 
count=0#记数’o' 
for x in s2:   
          if   x=='o':
              count+=1 
s2='o'*count
l2=list(s2)
print(l2) ```

结果:

（3）凭借 方括号 ‘[ ]’ 索引获取字符串中的字符

当索引正数是以最左边为0到最右的时候停止的记数 【0,numsize-1】
当索引负数是以最右边为-1到最左的时候停止的记数 【-numsize,- 1】

通过索引获取字符串中字符

通过索引访问字符串特定位置 S[i]

格式：(string)[<索引>]
VSCODE

IDLE

（4）凭借 ’ [ : ] ’ 截取字符串中的一部分 【变量[头下标:尾下标]】

用于截取字符串中的一部分，遵循左闭右开原则 …arr[0:6] 是不包含第 5 个字符的
分为两种：普通的片段切割–和-隔点切割.

（1）普通的片段切割

普通切割 S[i:j]

thon="worlder"
print(thon[2:5])
print(thon[3:])
print(thon[:4])
print(thon[-3:])
print(thon[:-2])
print(thon[-3:-1])

错误的是 大：小
print(thon[5:2] )#要从小到大才能输出
print(thon[-1:-3]) #要从小到大才能输出

x="hello"
print(x[1])# e
print(x[1:3])#el
print(x[1:])#ello
print(x[:-1])#hell

>IDLE

（2）隔点切割

隔着K个切割 S[i:j:k]

x="hello"
print(x[1])# e
print(x[1:5:2])

（5）int 与 not in

thon="worlder"
x="w" in  thon
print(x)
y='h 'not in thon 
print(y)
z='w' not in thon
print(z)

in 成员运算符 - 如果字符串中包含给定的字符返回 True
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True

（6） r/R–原始字符串:

直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。

print( r'\t' )
print( R'\t' )

（7）string.format（）—> 字符串类型的格式化

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

槽的内部样式如下：{<参数序号>: <格式控制标记>} <填充><对齐><宽度>,<.精度><类型>6个字段

s1="hello world"
i=0
for c in s1:
     print(format(i,"2d"),c)
     i=i+1
else:
     print("打印结束")

b=list(s1)
for c in b:
     print(format(i,"2d"),c)
     i=i+1
else:
     print("打印结束")

（8）其他

str="*My_ wri*te Python*"
# for x in str:
#  print(x ,end=" ")
# print('\n')
#  #去除无用/不想要的的字符 strip(）去除字符串的首尾字符
# print(str.strip())
# print(str.strip("*"))


##split  分割
print(str.split(" "))
b=str.split(" ")
print(b)
c=str.join("ooo")
print(c)
d="ppp.".join(b)
print(d)

<3>转义字符

Python 特殊字符使用反斜杠(“”)进行转义，由反斜杠(“”)和紧接的字符组成转义特殊
字符串中的单引号和双引号也逃逸不了特殊字符的含义

\\
\"
\n	换行
\t	横向制表符、
\r	回车，将 \r 后面的内容移到字符串开头

<4> Python中的>–str字符串–<内置方法

可以通过 for 和 in 组成的循环来遍历字符串中每个字符

 for <var> in <string>:
        操作内容

（1）字符串大小写转换：

这个我个人感觉比C语言的库函数好一些，不用引用【声明】需要用到的库才能使用。

Str.lower（）: 字母大写转换成小写。
Str.upper（）: 字母小写转换成大写
Str.swapcase（）:字母大写转换小写，小写转换成大写
Str.title（）: 将首字母大写

（2）字符串搜索、替换

Str.find(subst,[start, [end]l): 返回S 中出现 Str 的第一个字母的标号，如果 S 中没有 Str 则返回-1，start 和 end 作用就相当于在 Str[start;end]中搜索。
Str.count(substr,[start,[end]) : 计算Str 在 S中出现的次数。
Str.replace(oldstr, newstr, [count]): 把 Str 中的 oldstar 替换为 newstr，count 为替换次数。
Str.strip([chars]): 把 S左右两端 chars 中有的字符全部去掉，一般用于去除空格

举例Str,find 的使用将CSDN的本人的Python怎么学（持续更新）博客网站并存入txt文件中

from urllib import request 
str0='<a class="follow-nickName " href="https://blog.csdn.net/m0_74154295/article/details/129381111?spm=1001.2014.3001.5501" target="_blank" rel="noopener" title="Fairy_CYX">Fairy_CYX</a>'
title=str0.find("title")
print(title)
href1=str0.find("href=")
print(href1)
target=str0.find("target")
print(target)

url=str0[href1:target]
print(url)
frr=open('haasd','w+')
frr.write(url)
frr.close()

存入情况 ，运行后在VScode的终端结果中用 Ctrl+单击便可以进入该网站查看本人的《Python怎么学（持续更新）链接: http://t.csdn.cn/Tv0I51》这篇文章

（3）字符串分割、组合

Str.split([sep,[maxsplit]]): 以 sep 为分隔符，把 Str 分成一个 list。maxsplit 表示分割的次数，默认的分割符为空白字符。
Str.join(seq):把seq 代表的序列-字符串序列，用Str 连接起来。

（4）字符串测试【判断字符串Str中是否含有该字符】

Str.isalpha（）: Str是否全是字母，至少有一个字符
Str.isdigit（）: Str是否全是数字，至少有一个字符。
Str.isspace（）:Str是否全是空白字符，至少有一个字符
Str.islower（）:Str中的字母是否全是小写
Str.isupper（）: Str中的字母是否全是大写,
Str.istitle（）:Str是否是首字母大写的。

<5>Python三引号

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

二、list列表 -->（复合数据类型、序列类型）：

#字面量
[2,3.14,"123",[1.2.3]，True]
#空列表：
a=[]
b=list(想要转换类型的一个数据容器）

（1）什么是list列表

(1)列表是一种特别的对象集合，它的元素也由序号（下标）区分，但是各元素的类型可以是任意对象，不同元素不必是同一类型。元素本身允许是其它复杂数据类型.列表的数据项不需要具有相同的类型
(2)可以进行的操作包括索引，切片，加，乘，检查成员。

list1=[1,'2as',(21,34),[123,3,44],{'a','dasf',12}]
print(type(list1))
print(len(list1)
print(list1)

检测并len

（2）建一个list—>不受接受类型的限制

列表名+赋值符号‘=’+中括号‘[]’+逗号‘，’

• 用中括号 [] 括起来的数据，里面的每一个数据就叫做元素。每个元素之间使用逗号分隔。
  

（3）访问列表中的值:

直接打印其类型及其索引；索引遵从序列索引的正向和反向

• 对于集合来说，是用哈希表来实现的。
• 每一次运行哈希值都不一样，所以显示顺序也是无序的，每次都不一样。
  

嵌套访问：

a=[1,1.1,"asd",[[1,2,[1,2,"adsczx"]]]]
print(a[3][0][2])
print(a[3][0][2][2])

嵌套访问原理：

这种嵌套访问的原理是通过多次使用索引来逐级获取列表中的元素。在给定的例子中，列表 a 是一个嵌套的数据结构。

首先，通过索引 a[3] 访问到列表 [[1, 2, [1, 2, “adsczx”]]]。
然后，再次使用索引 a[3][0] 访问到内部列表 [1, 2, [1, 2, “adsczx”]]。
接着，使用索引 a[3][0][2] 访问到内部列表的最后一个元素 [1, 2, “adsczx”]。
最后，使用索引 a[3][0][2][2] 即可获取到字符串 “adsczx”。
通过层层嵌套的索引，我们可以逐级访问到任意深度的嵌套元素。这种嵌套访问的原理允许我们处理复杂的数据结构并获取所需的特定值。

（4）更新列表list里面的值

直接 列表名【索引】= 更换的值或者类型

（5）list列表方法：

【1】list.append（）—>列表末尾添加某元素对象

- 方法原型

需要添加的元素的对象的模样

list.append(obj)

参数

不论是元素的个数是多少 或者说是什么样的数据类型
都不会解除需要添加的类型比方说：下面的例子还是会保留中括号’[]‘或者’{}’

给什么样就修改成修改后列表的样子

【2】list.clear （） —>用于清空列表，类似于 del list[:]

方法原型：

list.clear()

删除所有元素

【3】list.copy（） —>复制列表，类似于 a[:]。

方法原型：

复制所以元素

listx=list.copy()

此处的x代表的是另一个可以承接复制的列表

返回值

返回赋值的列表内的所以元素内容

【4】list.insert（） —>指定对象插入列表的指定位置

方法原型：

将list[side]插入某元素，其余的元素向后移动

list.insert(index, side)

index – 对象obj需要插入的索引位置。
side – 要插入列表中的对象。

【5】list.pop （） —> 用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

方法原型：

list.pop([index=-1])

运用

##pop(i)
list13=[12,45,4,3]
#移除指定元素
list13.pop(1)
print(list13)
#默认移除最后一个元素
list13.pop()
print(list13)

【6】list.remove （）—>用于移除列表中某个值的第一个匹配项。

（1）方法原型

list.remove(obj)

（2）区别于pop方法的是：

remove 是移除的是指定元素：不能默认移除最后一个元素。。。要不然会报错

（3）还能当做检查元素在不在 同与in、not in

【7】list.reverse （）—>反向列表中元素

方法原型：

list.reverse()

同样起到翻转作用的是：list4 [ : :-1]

例子：

# print(list4[::-1])
#翻转
list16=[21,321,44]
list16.reverse()
list17=list16[::-1]
print(list16)
print(list17)

结果：

【8】list.count（）—>统计个数

方法原型：

list.count(obj)

【9】list.extend （）—>在列表末尾一次性追加另一个序列中的多个值

方法原型：

list.extend(seq)

range取值【0，n-1】

【10】排序–List.sort

默认正序，但我们可以将反转设置为True

list.sort( key=None, reverse=False)

（6）列表转换成字符串

【1】join方法

返回通过指定字符连接序列中元素后生成的新字符串。

str.join(sequence)

【2】for循环一个一个的转换然后加

lis = [‘1’,‘2’,‘3’,‘4’,‘5’]
s = “”
for i in lis:
s = s + str(i) + " "
print(s)

（7）翻转字符串单词：

def func(s):
    list1 = s.split()
    s = ' '.join(list1[::-1])
    return s

print(func(" dsdf  ooo"))

讲个特殊的

a和b都指向内存中的同一个列表对象。当您将a = b赋值时，您并没有为a创建一个新的列表对象，而是创建了一个指向b指向的同一个列表对象的新引用。因此，通过a或b对列表对象进行的任何更改都会影响相同的底层列表对象

b = [1, 3, 345]
a = b
print(id(a))  # 打印列表对象的内存地址
print(id(b))  # 打印与上面相同的内存地址
a[0] = 123213
print(b)  # 打印[123213, 3, 345]

可以使用copy()方法或切片运算符：

b = [1, 3, 345]
a = b.copy()  # 或 a = b[:]
a[0] = 123213
print(b)  # 打印[1, 3, 345]

我们使用copy()方法或切片运算符为a创建一个新的列表对象。现在，当我们修改a[0]时，b不会受到影响，因为a和b指向内存中的不同列表对象。

三、tuple元组–>（复合数据类型、序列类型，不可被修改）：

#字面量
（2,3.14,"123",[1.2.3]，True）
#空元组：
a=（）
b=tuple(想要转换类型的一个数据容器）

元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。 只需要在括号中添加元素，逗号隔开

(1)什么是tuple元组

圆括号创建，逗号分割

变量名 =（元素a，元素x,"12"）

元组（tuple）是关系数据库中的基本概念，关系是一张表，表中的每行（即数据库中的每条记录）就是一个元组，每列就是一个属性。

1、使用括弧“()”来创建，例如，a=(1，2，3)；
2、使用逗号来创建，例如，b=2，4；
3、使用 tuple0函数把其他种类的序列转化为元组，例如，c= tuple(“Good!”)。

<1>特别的是

（1）元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用

不加逗号就是整型元素;
加上逗号，类型为元组.

（2）元组中如果存在列表是可以修改列表的内部的值

<2> 创建空元组

tup1 = ()

<3> 索引依旧

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0。与字符串相同的是：
正向递增的序号是【0，number.size-1】;
反向递减的序号是【-number.size， -1】；

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

不论是元组还是列表都是用中括号‘[ ]’来索引

（2）元组和列表的区别：

元组的声明使用小括号，而列表使用方括号，当声明只有一个元素的元组时，需要在这个元素的后面添加英文逗号；
元组不能像列表一样添加、删除和修改元素在程序运行过程中不能被修改。

（3） 可以用切片解出来，但不能换元素

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

（4）元组可用函数：

max；min；len；‘+’；‘*’；in/not in

特别的：

sorted区别于sort

（5）元组和列表区别：

元组和列表不同仅在于一个可修改，一个不可修改。其他方面几乎没什么区别。
由于元组不可修改的这一性质，一般在函数中需要返回多个返回值时，可以将这些返回值放入一个元组中返回。

四、set集合 —> 复合数据类型、无序组合

在高中时期什么学到的集合的性质是： 确定性，互异性，无序性

集合类型与数学中集合的概念一致，即包含 0个或多个数据项的无序组合集合中元素不可重复，元素类型只能是固定数据类型，例如: 整数、浮点数、字符串、元组等.

列表、字典和集合类型本身都是可变数据类型，不能作为集合的元素出现。

>能够进行哈希运算的类型，都可以作为集合元素。 Python提供了一种同名的具体数据类型一一集合 (set)

由于集合是无序组合，它没有索引和位置的概念，不能分片，集合中元素可以动态增加或删除·集合用大括号 ({}) 表示，可以用赋值语句生成一个集合
创建一个空集合必须用 set()因为 { } 是用来创建一个空字典。

<1>.内置方法：

（1）set.add（x) —> 如果x不存在set中，那就添加进去

x={1,2,'a'}
print(x)
#由于集合有三大特性之一：互异性，所以不会再出现一个数字1
x.add(1)
print(x)
x.add('p')
print(x)
#但是会出现字符'1',这是由于Ascii码值
x.add('1')
print(x)

（2）set.clear（ ）移除set中所有元素：

（3）set.copy（ ）—>拷贝一个集合

（4）set.pop（）—>随机移除一个元素

参考并总结如下:

1、当集合的元素都是数字,  删掉的是最小的数字, 其余数字呈现升序排列   
2、当集合的元素是非数字, 删掉的是随机的元素, 其余元素呈现随机排列
3、如果集合里既有数字又有非数字元素, 删除时: 
若删掉的是数字, 则一定是删掉了最小的, 其他数字升序排列, 非数字元素随机排列;
若删掉的非数字, 则一定是随机删掉了一个, 其他数字升序排列, 非数字则随机排列.

（5） set.discard （x）—>如果x在集合 Set中，移除该元素;如果x不在，不报错

（6）set.remove （）—>如果x在集合S中，移除指定元素;不在产生 KeyError异常

keyerror一般是使用字典里不存在的key产生的错误，避免产生错误的方法很简单，使用字典的get方法为接受一个key和一个默认值，这个默认值只有key不存在的使用返回，存在则只接访问key的值。

（7）set.isdisjoint （ ）—>判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

（8）常用的len ,in/not in

<2>.set.操作符and内置方法使用 —>表示同种能力的办法:

操作符表达了集合类型的 4 种基本操作，交集（ & ）并集（ | ）、差集 （ - ）、补集 ( ^ )操作逻辑与数学定义相同

还有判断真子集，真超集合的<= >=

【1】【用于返回除去两个或更多集合中都共有的元素，即差集 （ - ）。】

《1》Set-T或 Set.difference(T) ---->返回一个新集合，包括在集合 Set 中不在集合T中的元素

（1）Set.difference(T)方法原型：

#准确的来说是
result=set_X.difference(set_Y)
#或者
result=set_x.difference_update(set1，set2,set3....setn)

（2）返回值

用于计算差集的集合。返回一个集合，元素包含在集合 x ，但不在集合 y 

（3）代码演示：

difference是得有一个空间来承接去除元素的地方

x = {"1", "2", 3}
y = {"2", 2, "python"}
 #difference是得有一个空间来承接去除元素的地方
x.difference(y) 
print(x)
x = x.difference(y) 

《2》Set-=T或Set.difference_update(T) —>更新集合Set，包括在集合S中不在集合T中的元素

（1）Set.difference_update(T)方法原型：

set_x.difference_update(set_y)

也可以

set_x.difference_update(set1，set2,set3....setn)

（2）返回值：

无返回值，即不能用一个变量来存放，若存放即为None

（3）代码演示：

（4）对比difference 和 difference_update(T)

相同点：去除集合S中不在集合T中的元素。 Set-=T 两个都可以
不同点： difference_update（）是直接在原来的集合中移除元素，没有返回值。

【2】【用于返回两个或更多集合中都包含的元素，即交集（ & ）。】

《1》Set &T 或Set.intersection(T) —>返回一个新集合，包括同时在集合 S 和T中元素。

（1）方法原型：

result=set_X.intersection(set1, set2 ... setn)

（2）返回值：

返回一个新的集合。若无交集就是set（）表示为空

（3）代码演示

x = {“1”, “2”, 3}
y = {“2”, 2, “python”}
z = {2,3}
print(x.intersection(y))
print(x.intersection(y,z))

《2》Set&=T或Set.intersection update(T) —>更新集合S，括同时在Set和T中元素

（1）方法原型：

set.intersection_update(set1, set2 ...setn)

（2）返回值：

无返回值，即不能用一个变量来存放，若存放即为None.

set1 -- 必需，且至少一个。要查找相同元素的集合
set2 ~ setn  -- 可选，其他要查找相同元素的集合，多个使用用英文状态的逗号 , 隔开

【3】【返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素，即补集 ( ^ )】

《1》Set^T或Set.symmetric_difference(T ) —>移除两个集合中都存在的元素。

只接受一个参数

（1）方法原型

result=set.symmetric_difference(set)

但不能在方法里面加入多个参数否则会报错

TypeError: set.symmetric_difference() takes exactly one argument (2 given)
类型错误：set.symmetric_difference（）只接受一个参数（给定2个）

（2）返回值

返回一个新的集合。两个集合组成的新集合，但会移除两个集合的重复元素

（3）特殊的set_x ^ set_y

这个可以多个这种操作

《2》Set=^T或Set.symmetric_difference_updat（T）---->更新集合S，包括集合ST中元素，但不括同时在其中的元素

（1）方法原型：

set.symmetric_difference_update(set)

（2）注意

同样的是：无返回值，即不能用一个变量来存放，若存放即为None.
    set.symmetric_difference_update() takes exactly one argument (2 given)
    类型错误：set.symmetric_difference_update（）只接受一个参数（给定2个）

（3）代码举例：

x = {"1", "2", 3}
y = {"2", 2, "python"}
z = {2,3}
x.symmetric_difference_update(y)
print(x)

{2, 3, 'python', '1'}

【4】【一个新集合，包括集合Set和T中所有元素。即并集（ | ）】

《1》S|T或S.union(T) —>集合Set和T中所有元素

（1）方法原型：

set.union(set1, set2...)

（2）返回值

返回一个新集合，其中
	set1 -- 必需，合并的目标集合
	set2 -- 可选，其他要合并的集合，可以多个，多个使用英文状态的逗号 隔开。

（3）代码：

``c
x = {"1", "2", 3}
y = {"2", 2, "python"}
z = x|y
print(z)
a={1,3}
b={23,'1'}
print(a.union(b))

《2》Set=|T或Set.update(T)—>更新合Set，括Set和T中所以元素[给集合添加元素]

（1）方法原型：

set.update(set)

（2）返回值：

不能用一个“容器”来承接否则会None

【5】其他

《1》Set<=T或 Set.issubset(T) —>如果Set与T相同或Set是T的子集，返True，否则返 False，可以用Set<T判断 Set是否是T的真子集

z = x.issubset(y,a)
TypeError: set.issubset() takes exactly one argument (2 given)

《2》Set>=T或 Set.issuperset(T) —>如果Set与T相同或Set是T的超集，返回True，否则返回False,Set>T判断Set是否是T的真超集

判断指定集合的所有元素是否都包含在原始的集合中，

《3》代码展示：

五、dict字典 —>(key，value)

映射类型是“键-值”数据项的组合，每个元素是一个键值对，即元素是(key，value)，元素之间是无序的。
键值对 (key，value) 是一种二元关系，源于属性和值的映射关系，键( key) 表示一个属性，也可以理解为一个类别或项目，值 ( value ) 是属性的内容，键值对刻画了一个属性和它的值。键值对将映射关系结构化，用于存储和表达。在 Python 中，映射类型主要以字典 (dict) 体现

 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中

 dict = {key1 : value1, key2 : value2, key3 : value3 }
 键必须是唯一的，但值则不必。`如果重复最后的一个键值对会替换前面的，值不需要唯一。`
 值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

访问：

创建：

使用大括号 { } 创建空字典：a={}
###
内建函数 dict() 创建字典： a=dict()

len --长度
type（）–类型

修改：

向字典添加新内容的方法是增加新的键/值对

像C语言一样，修改数组元素。

DICT1={'A':1,"312":'AAA',1:'ASD123'}
DICT1['312']=888888

常用操作：

dcit.keys（）： 返回一个包含字典dict所有 key 的列表
dict.values（）:返回一个包含字典dict所有 value 的列表。
dict.items（）:返回一个包含所有(键,值)元组的列表
dict.clear(): 删除字典dict中所有的元素。
dict.get(key): 返回字典dict中 key 所对应的值

第三节：Python的控制语句

运算符：

算数运算符、关系运算符、成员运算符

（1）python不支持自增运算符和自减运算符，但i+=1是可以的
（2）不等于为!=或<>	
（3）逻辑表达式中and表示逻辑与，or表示逻辑或，not表示逻辑非

流程框图：
程序框图的设计是在处理流程图的基础上，通过对输入输出数据和处理过程的详细分析，用于简单模拟计算机程序。是算法的一种图形化表示方法，使程序更直观、更清晰、更易理解。

三大结构：
不论是什么样的算法都具有着顺序结构，分支结构，循环结构这三大结构组成了计算机的基本结构

顺序结构

按语句的顺序一条一条一次执行，只要语法正确就会按照行数和缩进规则且无跳转的程序，直至整个程序的生命结束为止。

分支结构：

分为 单分支，双分支和多分支结构还有嵌套的情况。【在Python中是没有Switch-case这样的结构的】

单分支结构（if）：

if（表达式）：
    代码段

if 中的表达式成立就执行其代码块里面的语句。
不成立就“屏蔽“了这段代码。

if语句的注意事项:

if 判断的条件:
	条件成立时，要做的事情

1、判断条件的结果一定要是布尔类型，判断条件后的冒号：
2、if语句的代码块，需在前方填充4个空格缩进（用Tab或者全选代码然后格式化文档【用编写代码的软件的语言格式化】）

双分支结构（if - else）

if（表达式1）：
    代码段1
else（表达式2）：
    代码块2

if 中的表达式成立就执行其代码块里面的语句。
不成立就执行代码块2的内容
else的代码块，同样要4个空格作为缩进（用Tab或者全选代码然后格式化文档【用编写代码的软件的语言格式化】）

嵌套（if-else-else–…）

只要是if和else缩进对齐规则到位就行.

if-elif

if no1.condition、
    语句1
elif no2.condition
    语句2
elif no3.condition
    语句3
else  no.condition
    语句n

（1）只要if起头 elif紧跟才不会报错。
（2）对于else来说是可加可不加的。
（3）一定注意缩进对齐的原则

f=int(input("请输入一个sccore"))

if f>85:
  print("Youxiu")
elif f>75:
      print("ken")
elif   f>=60:
 print("1111")

嵌套的关键点在于空格缩进
通过空格缩进决定了语句之间是层次关系

Python中的判断有几种：

（1）if–else 对齐的判断【这种中规中矩的写法，虽然行数较多，但能够直观判断】
（2）三目运算符：a = "真 if 判断进入的条件 else 不满足的输出
（3）[]索引判断：具体看我这篇文章的（13）查找部分Python小技巧
有字典，元组和列表的判断，

num = int(input(""))
result = {0: "Yes", 1: "No"}[num &1]
print(result)

#列表索引：您可以使用列表根据索引执行查找。以下是一个示例：
num = int(input(""))
result = ["Yes", "No"][num % 2]
print(result)

（4）“短路原则” result=判断条件 and 真 or 假
（5）字符串切片的原理+Boolean【这是我见过的秒的方法】
result=‘未成年’[age>18]

在 Python 中，用于切片的语法是 [start:stop:step]
在Python 中的布尔值 True 和 False 分别对应整数 1 和 0，
	因此表达式 age > 18 的结果可以是 1 或 0。
这意味着当 age 大于 18 时，索引值为 1，否则索引值为 0

循环

在Python中分为while和for两种【因为在python的关键字中没有do的存在，所以无do…while这种循环功能】

1.for语句（确定次数循环即遍历循环）
2.while语句（非确定次数循环）

注意事项：
不论是什么样式的循环方式都应当遵守
有初始条件，终止条件，步长且要有良好的控制，不要使得程序成为一个死循环

while循环语句

while 判断条件：
   语句

若判断条件为True，则执行while循环中的代码段；
若判断条件为False，终止while循环。
若while循环的判断条件总是True，便是死循环 。【CTRL+C 来退出当前的无限循环】 

while-else语句

这个是不能有多个else的。

仅仅是当while因条件为假而退出(即没有被break中断)时运行else块

while 判断条件：
   语句
else ：
   语句

观察下方的拼图，我们不难发现的是，有break的语句仅仅输出一次就结束了，不会回到while也不会运行else的片段语句。

for循环语句：迭代用于反复执行相同的操作，直到满足特定条件为止。

确定循环次数和循环结束的条件

for 临时变量 in 待处理的数据源（存放元素的容器[^什么是数据容器]：字符串，列表，元组，字典，集合）

1. 列表（List）：有序可变的数据容器，使用方括号 [] 表示。列表可以包含不同类型的元素，并且支持修改、增加或删除其中的元素。

示例：

my_list = [1, 'hello', 3.14, True]

2. 元组（Tuple）：有序不可变的数据容器，使用圆括号 () 表示。元组创建后不能修改其内容。

示例：

my_tuple = (1, 'hello', 3.14, True)

3. 集合（Set）：无序可变的数据容器，使用大括号 {} 表示。集合中不允许重复的元素存在。

示例：

my_set = {1, 'hello', 3.14, True}

4. 字典（Dictionary）：键值对的数据容器，使用大括号 {} 表示。每个元素由一个键（key）和对应的值（value）组成。

示例：

my_dict = {'name': 'John', 'age': 30, 'is_student': False}

在使用这些数据容器时，你可以根据具体的需求选择合适的类型来存储和处理数据。每种数据容器都有其特定的用途和优势，例如，如果需要有序且可修改的容器，可以选择列表；如果需要去重并且顺序不重要的容器，可以选择集合。

range（）函数–遍历整数的

在Py2中却是返回一个列表
而在py3中返回的是一个返回的是一个可迭代对象，print打印的时候不会打印列表。
如果也要转化为列表就 list（）里面嵌套range（）。
左闭右开的区间

range(stop)
range(start, stop[, step])

（1）start: 计数从 start 开始。默认是从 0 开始。
例如 range(8) 等价于 range（0，8)中遍历元素0,1，2，3,4，5,6，7
（2）stop: 计数到 stop 结束【即不包含stop】。例如：range(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
（3）step：步长，默认值为 1。例如：range(0， 5) 等价于 range(0, 5, 1)
（4）若使用负数作为步长，以便从结束值倒序生成序列

注意事项：

i=121212
print（i）
for  i in range(4):
    print(i)
    
print(i)

第15行的i和第16行的i是两个不同的变量。虽然它们的名称相同，但它们在不同的作用域中。
在第15行，i是一个局部变量，它只在for循环的作用域内有效。每次迭代时，i的值会被更新为range(4)中的下一个值。

然后，在第16行，i是一个全局变量，它在整个文件的作用域内有效。它的初始值是在文件的顶部定义的i=121212。

因此，第15行的i不会影响第16行的i，它们是两个不同的变量。如果您希望第15行的i影响第16行的i，您可以将第15行的i更改为全局变量，或者在第16行之前将其赋值给第16行的i。

你可以使用切片操作来实现这个目的。切片操作可以用来获取一个序列（如字符串、列表等）的子序列。

在 Python 的 for 循环中，循环变量（例如 i）会在每次迭代开始时被赋予序列中的下一个值。这意味着你不能直接将循环变量赋值为索引，然后开始遍历。循环变量在每次迭代中自动获取序列中的下一个值。
使用 for 循环进行迭代。for 循环是一种迭代结构，用于遍历序列（如列表、字符串等）中的元素。每次迭代，循环变量（在这里是 item）会自动取得序列中的下一个值，并执行相应的操作。

for-else 遍历循环的一种扩展模式

当for循环正常执行之后，程序会继续执行else语句中内容。
else语句只在循环正常执行之后才执行

for  <循环变量>  in  <遍历结构>:
    语句块1
else:
    语句块2

保留字break和continue

break语句跳出最内层for循环，但仍然继续执行外层循环。每个break语句只有能力跳出当前层次循环。
continue用来为只是中止(跳过)本次循环，接着开始下一次循环。并没有使整个循环终止。对于while循环，继续求解循环条件。而对于for循环，程序流程接着遍历循环列表。continue 只能在循环语句中使用

pass语句：

与其本身意思相同–过。
pass的意思是空语句，pass语句不做任何事情。
我的感觉是和if语句在某些方面上有异曲同工之妙。

可以用在死循环无法破解的时候，有点类似于C语言中的goto
Python不许有空的语句块或空函数出现，所以使用pass语句进行占位，以便今后进行实现。
（即：在python中定义一个def函数，内容为pass。pass主要作用就是占据位置，
	让代码整体完整。当我们定义了一个函数内容为空，
	那么就会报错，当你还没想清楚函数内部内容，就可以用pass来进行填坑。）

函数

一般来说，只有那些使用频繁或者和语言本身联系紧密的函数，使用必须通过严格控制，否则 Python 解释器会变得庞大和臃肿。才会被上升为内置函数。

函数是一种调用时运行的代码块。把数据作为结果返回。

是经被封装好的、可重复使用的已一段代码块；用来实现某单一，有关联功能的代码段。
最普通的一个函数就是print（与本文学习没有太大关系的像C语言中最普通的就是scanf和printf. ）

print（）函数

方法原型

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep – 用来间隔多个对象，默认值是一个空格。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
【我们可以将后面的end改为end=“”，就可以取消自动换行】
file – 要写入的文件对象。
flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

这种已经封装完毕的函数，可以直接拿来使用。

创建和调用：

创建函数：

（1）用 def 关键字来定义,后接圆括号（）接受标识符参数。【圆括号之间可以用于定义参数。】
（2）函数内容以冒号 : 起始，并且缩进.
（3）return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

def 函数名（参数列表）:
    函数体

若有返回参数的加上return

代码实例

def  hello（）： 				 #def定义
     print（"hello"）			 #函数体
hello（）    					 #调用函数

def max(a, b):    #函数传参   #def定义
    if a > b:
        return a                #函数体
    else:
        return b                #return 传回参数

传参：

值传递：适用于实参类型为不可变类型（字符串、数字、元组）；
引用（地址）传递：适用于实参类型为可变类型（列表，字典）；

	值传递和引用传递的区别是，函数参数进行值传递后，若形参的值发生改变，不会影响实参的值；
而函数参数继续引用传递后，改变形参的值，实参的值也会一同改变。

不能这样传参，有固定参数靠右。

lambda函数

lambda 的主体是一个表达式，而不是一个代码块。
拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

方法原型：

lambda [arg1 [,arg2,.....argn]]:expression

map函数

map() 会根据提供的函数对指定序列做映射。

map(function, iterable, ...)

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表

enumerate函数：

enumerate()是python的内置函数，用于将一个可遍历的数据对象(如列表、元组或字符串等)组合，多用于for循环。

enumerate(a,start)

a是可迭代对象，start是计数起始数

第四节 文件File使用方法：open close

读写文件是最常见的 IO 操作。Python 内置了读写文件的函数，用法和 C 是兼容的。
在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的程序直接操作磁盘
所以，读写文件就是请求操作系统打开一个文件对象(通常称为文件描述符)，
然后，通过操作系统提供的接口从这个文件对象中读取数据(读文件)，
或者把数据写入这个文件对象(写文件)。

相信大多数人接触了word文档等一系列可以记录数据或者内容的app或者网站或者软件
开关文件，输入删除内容文档等等操作是做常规的了。

【1】在什么位置当前工作的—文件路径

首先我们简单将一下引入os模块

import os
os.getcwd()

在python中提供了一种函数【os.getcwd（）】获取该文件当前工作路径的字符串

利用 os.chdir() 改变路径

关于文件，它有两个关键属性，分别是“文件名”和“路径”。
（1）文件名指的是为每个文件设定的名称，
（2）路径则用来指明文件在计算机上的位置。
（3）Windows上的反斜杠以及OS X和Linux上的正斜杠， 作为文件夹之间的分隔符。

文件名：
文件路径位置

相对路径和绝对路径

绝对路径：总是从根文件夹开始，Window 系统中以盘符（C：、D：）作为根文件夹，
			而  Linux 系统中以 / 作为根文件夹。
相对路径：指的是文件相对于当前工作目录所在的位置。

【2】文件的基本操作：

常见的操作包括创建、删除、修改、读取、写入等。

删除、修改权限：作用于文件本身，属于系统级操作。
写入、读取：是文件最常用的操作，作用于文件的内容，属于应用级操作。

（1）打开文件：使用 open() 函数，该函数会返回一个文件对象；
（2)对已打开文件做读/写操作：
		读取文件内容可使用 read()、readline() 、readlines() 函数；
		文件中写入内容，可以使用 write() 函数。
(3)关闭文件：完成对文件的读/写操作之后，最后需要关闭文件，可以使用 close() 函数。

[打开---->读写---->关闭]  这三个操作缺一不可且顺序不可改变。  

open() 函数用于创建或打开指定文件

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode='r')

完整的语法格式为：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
file: 必需，文件路径（相对或者绝对路径）。

> mode: 可选，文件打开模式 
> buffering: 设置缓冲 
> encoding: 一般使用utf8 
> errors: 报错级别
> newline: 区分换行符 
> closefd: 传入的file参数类型 
> opener:

中文翻译

操作【只读read、只写write、追加】

copy复制 move移动

只读模式（r）打开文件，则只能从文件中读取而不能修改其内容。如果您以只写模式（w）打开文件，则可以写入新内容，但会清除文件的现有内容。如果您以追加模式（a）打开文件，则可以将新内容添加到文件的末尾，而不会影响文件的现有内容。
当我们在尝试打开不存在的文件，则会引发FileNotFoundError异常。
想要在文件不存在时创建一个新文件，则可以使用w或a模式打开文件。

操作的文件必须存在。

r：只读模式。打开文件以进行读取，并将文件指针放置在文件开头。文件必须存在。
rb：二进制格式的只读模式。类似于r，但用于非文本文件，如图像或音频文件。
r+：读写模式。打开文件以进行读取和写入。
		文件指针放置在文件开头。写入新内容将覆盖相同长度的现有内容。
rb+：二进制格式的读写模式。类似于r+，但用于非文本文件。

若文件存在，会清空其原有内容（覆盖文件）；反之，则创建新文件。

w：只写模式。打开文件进行写入。如果文件存在，则清除其内容。
		如果文件不存在，则创建一个新文件。
wb：二进制格式的只写模式。类似于w，但用于非文本文件。
w+：读写模式。类似于w，但还允许从文件中读取。
wb+：二进制格式的读写模式。类似于w+，但用于非文本文件。

追加

a：追加模式。打开文件进行写入，但将文件指针放置在文件末尾。
		如果文件存在，则新内容将添加到文件末尾。如果文件不存在，则创建一个新文件。
ab：二进制格式的追加模式。类似于a，但用于非文本文件。
a+：读写模式。类似于a，但还允许从文件中读取。
ab+：二进制格式的读写模式。类似于a+，但用于非文本文件。

我经常能在一个文件夹里面看到.docx的打卡是

在文本模式下打开文件和在二进制模式下打开文件的区别在于，
（1）在文本模式下，文件被视为文本文件，您可以读取和写入字符串【文件中的数据被视为文本字符串】，
（2）而在二进制模式下，文件被视为二进制文件【文件中的数据被视为字节序列。】
	这意味在读取和写入操作时候可以使用字节串方法处理文件中的数据。
	[read()方法读取文件数据，可以使用字节串方法处理数据]
（3）需要注意的是，以文本格式打开二进制文件，或以二进制格式打开文本文件，
则可能会导致数据损坏或无法处理。因此，您应该根据文件的实际内容选择正确的打开模式。

那上图举例，如果强行打开就会出现乱码情况：

小知识点

在Python中，介于-5和256之间的整数被缓存并重用，因此如果它们在代码中的多个位置使用，则它们的内存地址将相同。但是，对于这个范围之外的整数，例如1113，情况并非如此。因此，1113的内存地址与代码中其他1113实例的内存地址不同。

关于a和b中元素的内存地址，重要的是要注意，即使两个列表具有相同的元素，它们仍然是内存中的单独对象。因此，即使它们具有相同的值，a和b中元素的内存地址也不会相同。

讲：

a 和 b 是两个不同的列表，但是它们包含相同的对象。当 a[1] 被改为 123 时，b 中该索引处的值也被改为 123。这是因为 a 和 b 是两个不同的列表，但它们包含相同的对象。当一个对象在一个列表中被改变时，它也会在另一个列表中被改变，因为它们都引用内存中相同的对象。

另一方面，c 和 d 是两个引用同一列表对象的不同变量。当打印 d 时，它与打印 c 相同，因为它们都引用内存中相同的列表对象。当通过将 c[0] 设置为 123213 来更改 c 时，d 也会更改，因为它们都引用内存中相同的列表对象。

总之，a 和 b 之间的区别以及 c 和 d 之间的区别在于，a 和 b 是两个包含相同对象的不同列表，而 c 和 d 是引用内存中相同列表对象的两个不同变量。

总结：一个为了节省空间，一个只是多了一个名字而已

到了这里，关于我在VScode学Python（Python的基本了解，数据类型，控制语句，文件File）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！