python基础

最新推荐文章于 2024-10-12 12:26:23 发布
最新推荐文章于 2024-10-12 12:26:23 发布
阅读量682 收藏 26
点赞数 29
文章标签： python 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_78029885/article/details/141224663
版权

1 编码

0/1组合。

使用不同编码保存，硬盘中存储的0/1不同。

以什么编码保存，用什么编码打开。

2 编程初体验

  • 保存与打开编码必须一致，否则会乱码。

  • 默认python解释器以utf-8去打开。想修改默认解释器编码：

    -*- coding:gbk -*-

  • 建议所以python代码以utf-8形式去保存和读取。

3 输出

  • 默认print输出加换行符。

  • 不换行

    print("hello",end="")
    print("hello",end=",")
print("hello",end=".")

4 数据类型

4.1 整型int

print(666)

4.2字符串str

print("我是Alex")
print("""hfue
fjefir
snfef""")

单行或者多行字符串。

  • 加，两个字符串可以通过+拼接起来。

    print("ni"+"hao")
nihao

  • 乘，整型与字符串相乘，实现让重复出现N次并拼接起来。

    print("nihao1" * 3)
nihao1nihao1nihao1

    4.3布尔类型bool

只有两种值：true/false。

print(1 > 2)
print(False)
print(1 == 1)
print(True)

4.4类型转换

print(int("666"))
int("6")+int("9") 15
int("alex") 报错
int(True) 1
int(False) 0
str(345)
str(True)
bool("hello") True
bool("") False

  • 其他所有类型转布尔类型时，除了空字符串、0，其他都是True。

  • 字符串转整型，只有"999"可以转换，其余报错。

  • 想转哪个类型，用这类型英文包裹一下即可。

5 变量

变量名=值，以后可以通过变量名来操作其对应的值。

name="wupeiqi"
print(name)

  • 给变量赋值，age=18

  • 让age代指值，age=18

5.1 变量名规范

  • 变量名只能是数字、字母、下划线组成。

  • 不能以数字开头。

  • 不能用python关键字。

  • 下划线连接命名。(小写)

    father_name="wupeiqi"

  • 见名知意。

5.2 变量内存指向关系

6 注释

单行注释

# 这是注释

多行注释

"""多
行
注
释"""

7 输入

name=input("请输入：")
if name=="alex":
    print("ok")

8 条件语句

if 条件：
    条件成立执行
else :
    条件不成立执行
if 条件1:
    条件1成立执行
elif 条件2:
    条件2成立执行
else:
    上述都不成立执行
if 条件1:
    if 条件1.1:
        ...
    else:
        ...
elif 条件2:
    ...

9 循环语句

  • while循环

  • for循环

while 条件:
    循环语句

9.1 循环语句基本使用

print("start")
while True:
    print("alax")
print("end")

9.2小案例

用户登录系统，若密码错误反复输入，直至正确。

print("start")
while True:
    user = input("请输入用户名:")
    pwd = input("请输入密码:")
    if user == "wupeiqi" and pwd == "123":
        print("sucess")
        break
    else:
        print("false")
print("end")

9.3 break

用于在while中终止循环。

9.4 continue

在循环中结束本次循环，开始下一次循环。

9.5 while else

while 条件不成立，else中代码就会执行。

while XX:
    ...
else:
    ...

10 字符串格式化

字符串格式化，使用更便捷的方式实现字符串的拼接。

10.1 %

10.1.1 基本格式化

name="wupeiqi"
text="我叫%s，今年18岁" %"wupeiqi"
text="我叫%s，今年18岁" %name
name="wupeiqi"
age=18
text="我叫%s，今年%d岁" %(name,age)
print(text)
message="%(name)s什么时候过来" %{"name":"死鬼"}
print(message)

10.1.2 百分比

text="%s,这片我已经下了90%%了" %"兄弟"
print(text)

一旦字符串格式化中存在百分比显示，一定要%%去实现输出%。

10.2 format(推荐)

text="我叫{0},今年{1}岁。".format("wupeiqi",18)
text1="我叫{0},今年{1}岁,真实姓名是{0}。".format("wupeiqi",18)
print(text)
print(text1)
text1="我叫{},今年{}岁,真实姓名是{}。".format("wupeiqi",18,"wupeiqi")
print(text1)
text="我叫{n1}。".format(n1="wupeiqi")
print(text)
text="我叫{0}。"
data=text.format("wupeiqi")
print(data)

10.3 f

action="跑步"
text=f"嫂子喜欢{action}"
print(text)
text=f"嫂子喜欢{19+2}岁小伙"
print(text)
text=f"嫂子喜欢{19+2 =}岁小伙"
print(text)
v1=f"嫂子今年{22}岁"
print(v1)
v2=f"嫂子今年{22:#b}岁"
print(v2)
v3=f"嫂子今年{22:#o}岁"
print(v3)
v4=f"嫂子今年{22:#x}岁"
print(v4)
name="alex"
text=f"我是{name.upper()}"
print(text)

11 进制与代码

11.1 python代码运行方式

  • 脚本式

    python ~/XX/XX.py

  • 交互式

image-20240630113728661

11.2 进制

  • 二进制

0101

11.2.1 进制转换

25
bin(25)#十进制转二进制
oct(23)#十进制转八进制
hex(34)#十进制转十六进制
v1 = bin(24)
print(v1)  # "0b11000"
v2 = oct(34)
print(v2)  # "0o42"
v3 = hex(25)
print(v3)  # "0x19"
i1=int("0b11000",base=2)
i2=int("0o42",base=8)
i3=int("0x19",base=16)
print(i1)
print(i2)
print(i3)

11.3 计算机中的单位

由于计算机中本质上所有东西以二进制存储和操作，为了方便对二进制大小的表示，所以就搞了一些单位。

  • b(bit),位

    1 1位
10 2位
1001 4位

  • B(byte),字节

8位是一个字节
10010011 1个字节
10010011 11001110 2个字节

  • KB(kilobyte),千字节

    1024个字节就是一个千字节
1KB=1024B=1024*8b

  • M(Megabyte),兆

    1024KB=1M
1M=1024KB=1024*1024B=1024*1024*1024*8b

  • G(Gigabyte),千兆

1024M就是1G
1G=1024M=1024*1024KB=1024*1024*1024B=1024*1024*1024*8b

  • T(Terabyte),万亿字节

1024G=1T

11.4 编码

文字和二进制之间的一个对照表。

11.4.1 ascii编码

ascii规定使用一个字节来表示字母与二进制的对应关系。

00000000
00000001
00000010
...
11111111

11.4.2 gb-2312编码

gbk是对gb-2312的扩展。

在与二进制做对应关系时，有如下逻辑。

  • 单字节表示，用一个字节表示对应关系。2**8=256

  • 双字节表示，用两个字节表示对应关系。2**16=65536种可能。

11.4.3 unicode

也被称为万国码，为全球的每个文字都分配了一个码位(二进制表示)。

  • Ucs2

    用固定的两个字节去表示一个文字。

00000000 00000000

  • Ucs4

    用固定的4个字节去表示一个文字。

unicode的应用，在文件传输和网络传输时，不会直接使用Unicode。而在内存中会使用。

11.4.4 utf-8

包含所有文字和二进制的对应关系，全球应用最广泛的一种编码。

本质上：是对Unicode的压缩，用尽量少的二进制去与文字对应。

unicode码位范围         utf-8
0000-007F           用1个字节表示
0080-07FF           用2个字节表示
0800 FFFF			用3个字节表示
10000-10FFFF		用4个字节表示

具体压缩的流程：

  • 第一步：选择转换模板

    码位范围(十六进制)       转换模板
0000-007F			0XXXXXXXX
0080-07FF			110XXXXX 10XXXXXX
0800-FFFF			1110XXXX 10XXXXXX 10XXXXXX
10000-10FFFF		11110XXX 10XXXXXX 10XXXXXX 10XXXXXX

注意：一般中文都使用第三个模板，这也就是平时大家说中午在utf-8中占三个字节的原因。

  • 第二步：在模板中填入数据

    "武" 6B66 110 101101 100110
根据模板套入数据
1110XXXX 10XXXXX 10XXXXX
1110XXXX 10XXXXX 10100110
1110XXXX 10101101 10100110
11100110 10101101 10100110

11.5 python相关的编码

字符串(str) unicode 处理

字符(byte) utf-8/gbk编码

v1="武"

v2="武".encode("utf-8")
v3="武".encode("gbk")

将一个字符串写入到一个文件中。

name="XXX"
data=name.encode("utf-8")

#打开一个文件
file_object=open("log.txt",mode="wb")
#在文件中写内容
file_object.write(data)
#关闭文件
file_object.close()

12 数据类型 1

12.1 整型

12.1.1 定义

age=14

12.1.2 独有功能

无

age=18
print(age.bit_length())

12.1.3 公共功能

加减乘除

12.1.4 转换

XX=int(xx)

12.1.5 其他

12.1.5.1 长整型

  • python3 整型 (无限制)

  • python2 整型 长整型

int(整型) long(长整型) 都以L结尾 仅表示值范围不同

12.1.5.2 地板除

  • Py3

v1=9/2
print(v1) #4.5

  • Py2

v1=9/2
print(v1) #4
from __future__ import division

v1=9/2
print(v1) #4.5

12.2 布尔类型

12.2.1定义

data=False
text=True

12.2.2 独有功能

无

12.2.3 公共功能

无

v1=True+True
print(v1)	# 2

12.2.4 转换

整数0、空字符串、空列表、空元组、空字典转换为布尔值时均为False
其他为True

12.2.5 其他

12.2.5.1 做条件自动转换

12.3 字符串类型

字符串平时用来表示文本信息。

12.3.1 定义

v1="xx"
v2='xx'
v3="""
xx
xx
"""
#三个引号支持多行/换行表示一个字符串，其他都只能在一行中表示一个字符串。

12.3.2 独有功能(18/48)

"xx".功能()
v1="xxx"
v1.功能()

1.判断字符串是否以xx开头？得到一个布尔值

v1="我爱学习"
res=v1.startswith("我爱")
print(res)

2.判断字符串是否以xx结尾？得到一个布尔值

v1="我爱学习"
res=v1.endswith("学习")
print(res)

3.判断字符串是否为十进制数？得到一个布尔值

v1="1234"
res=v1.isdecimal()
print(res)

v1="1234"
res=v1.isdecimal()
print(res)

v2="①"
res=v2.isdecimal()
print(res)

v3="1234"
res=v3.isdigit()
print(res)

v4="①"
res=v4.isdigit()
print(res)

4.去除字符串两边的空格、换行符、制表符，得到一个新的字符串

msg=" h e l l 0,ge "
data=msg.strip()
print(data)
#h e l l 0,ge
#lstrip 去左边
#rstrip 去右边

补充：去除空格、换行符、制表符

msg="e h e l l 0,ge"
data=msg.strip("e")
print(data)
# h e l l 0,g

5.字符串变大写，得到一个新的字符串

data="hello"
res=data.upper()
print(res)
#HELLO

6.字符串变小写，得到一个新的字符串

data="ABCD"
res=data.lower()
print(res)

7.字符串内容替换，得到一个新的字符串

data="我爱吃饭，饭真香"
res=data.replace("饭","屎")
print(res)

8.字符串切割，得到一个列表

data="xx|xx|swe|detrg|dwd"
res=data.split("|")
print(res)
#['xx', 'xx', 'swe', 'detrg', 'dwd']
data="xx|xx|swe|detrg|dwd"
res=data.split("|",1)
print(res)
#['xx', 'xx|swe|detrg|dwd']
data="xx|xx|swe|detrg|dwd"
res=data.rsplit("|",1)
print(res)
#['xx|xx|swe|detrg', 'dwd']

9.字符串拼接，得到一个新的字符串

data_list=["nihao","shanghai"]
res="*".join(data_list)
print(res)
#nihao*shanghai

10.格式化字符串，得到新的字符串

name="{0}喜欢,biru{1}\{2}"
data=name.format("nihao","hao","ok")
print(data)
#nihao喜欢,biruhao\ok

11.字符串转换为字节类型

data="嫂子"#unicode
v1=data.encode("utf-8")#字节类型
v2=data.encode("gbk")#字节类型
print(v1)
print(v2)
#b'\xe5\xab\x82\xe5\xad\x90'
#b'\xc9\xa9\xd7\xd3'
s1=v1.decode("utf-8")
s2=v2.decode("gbk")
print(s1)
print(s2)

12.将字符串内容居中、居左、居右展示

v1="老汉"
data=v1.center(20,"*")
print(data)
#*********老汉*********

v1="老汉"
data=v1.ljust(20,"*")
print(data)
#老汉******************

v1="老汉"
data=v1.rjust(20,"*")
print(data)
#******************老汉

13.帮你填充0

data="alex"
v1=data.zfill(10)
print(v1)
#000000alex
#应用场景，处理二进制
data="101"#"00000101"
v1=data.zfill(8)
print(v1)

12.3.3 公共功能

1.相加：字符串+字符串

2.相乘：字符串*整数

3.长度

data="hhhuhie"
print(len(data))

4.获取字符串中的字符，索引

mes="你好哦"
print(mes[0])
print(mes[1])
print(mes[2])
print(mes[-1])
print(mes[-2])
print(mes[-3])
#你
#好
#哦
#哦
#好
#你

注意：字符串中只能通过索引取值，无法修改值。[字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。]

mes="你好哦"
index=0
while index<len(mes):
    print(mes[index])
    index+=1
mes="你好哦"
index=len(mes)-1
while index>=0:
    print(mes[index])
    index-=1

5.获取字符串中的子序列，切片

mes="来学习呀"
print(mes[0:2]) 	   #来学
print(mes[2:])  	   #习呀
print(mes[1:-1])       #学习
print(mes[2:len(mes)]) #习呀

注意：字符串中切片只能读取数据，无法修改数据。[字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。]

前取后不取

6.步长，跳着去取字符串的内容

name = "生活不是电影，生活比电影苦。"
print(name[0:5:2])  # 前两个值为区间范围，最后一个为步长 生不电
print(name[8:1:-1])  # 倒序 活生，影电是不
print(name[::-1])  # 。苦影电比活生，影电是不活生

7.循环

  • while

    name = "生活不是电影，生活比电影苦。"
index=0
while index<len(name):
    print(name[index])
    index+=1

  • for

    name = "生活不是电影，生活比电影苦。"
for i in name:
    print(i)

  • range,帮助我们创建一系列数字

range(10)#[0,1,2,3,4,5,6,7,8,9]
range(1,10)#[1,2,3,4,5,6,7,8,9]
range(1,10,2)#[1,3,5,7,9]
range(10,1,-1)#[10,9,8,7,6,5,4,3,2]

for i in range(10):
    print(i)
mes="你好我爱学习"
for i in range(len(mes)):
    print(mes[i])

一般应用场景：

  • while 一般在无限制，未知的循环处使用。

    while True:
    ...

  • for 一般应用在已知的循环数量的场景。

    #循环多少次

  • break continue关键字

    mes="你好我爱p学习"
for i in mes:
    if i=="p":
        continue
    print(i)
#你
#好
#我
#爱
#学
#习

mes="你好我爱p学习"
for i in mes:
    if i=="p":
        break
    print(i)
#你
#好
#我
#爱

12.3.4 转换

一般情况下，只有整型转字符串才有意义。

12.3.5 其他

12.3.5.1 字符串不可被修改

字符串只读。

字符串列表可读可修改。

12.4 列表

列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

12.4.1 定义

user_list =  ["苍老师","有坂深雪","大桥未久"]
number_list = [98,88,666,12,-1]
data_list = [1,True,"Alex","宝强","贾乃亮"]
user_list = []
user_list.append("铁锤")
user_list.append(123)
user_list.append(True)
print(user_list) # ["铁锤",123,True]

不可变类型：字符串、布尔、整型（已最小，内部数据无法进行修改）

可变类型：列表（内部数据元素可以修改）

12.4.2 独有功能

Python中为所有的列表类型的数据提供了一批独有的功能。

在开始学习列表的独有功能之前，先来做一个字符串和列表的对比：

  • 字符串，不可变，即：创建好之后内部就无法修改。【独有功能都是新创建一份数据】

    name = "alex"
data = name.upper()
print(name)
print(data)

  • 列表，可变，即：创建好之后内部元素可以修改。【独有功能基本上都是直接操作列表内部，不会创建新的一份数据】

    user_list = ["车子","妹子"]
user_list.append("嫂子")

print(user_list) # ["车子","妹子","嫂子"]

列表中的常见独有功能如下：

  1. 追加，在原列表中尾部追加值。

    data_list = []

v1 = input("请输入姓名")
data_list.append(v1)

v2 = input("请输入姓名")
data_list.append(v2)

print(data_list) # ["alex","eric"]
    # 案例1
user_list = []

while True:
    user = input("请输入用户名(Q退出)：")
    if user == "Q":
        break
    user_list.append(user)
    
print(user_list) 
    # 案例2
welcome = "欢迎使用NB游戏".center(30, '*')
print(welcome)

user_count = 0
while True:
    count = input("请输入游戏人数：")
    if count.isdecimal():
        user_count = int(count)
        break
    else:
        print("输入格式错误，人数必须是数字。")


message = "{}人参加游戏NB游戏。".format(user_count)
print(message)


user_name_list = []

for i in range(1, user_count + 1):
    tips = "请输入玩家姓名（{}/{}）：".format(i, user_count)
    name = input(tips)
    user_name_list.append(name)

print(user_name_list)

  2. 批量追加，将一个列表中的元素逐一添加另外一个列表。

    tools = ["搬砖","菜刀","榔头"]
tools.extend( [11,22,33] ) # weapon中的值逐一追加到tools中
print(tools) # ["搬砖","菜刀","榔头",11,22,33]
    tools = ["搬砖","菜刀","榔头"]
weapon = ["AK47","M6"]
#tools.extend(weapon) # weapon中的值逐一追加到tools中
#print(tools) # ["搬砖","菜刀","榔头","AK47","M6"]

weapon.extend(tools)
print(tools) # ["搬砖","菜刀","榔头"]
print(weapon) # ["AK47","M6","搬砖","菜刀","榔头"]
    # 等价于(扩展)
weapon = ["AK47","M6"]
for item in weapon:
    print(item)

# 输出：
#  AK47
#  M6
tools = ["搬砖","菜刀","榔头"]
weapon = ["AK47","M6"]
for item in weapon:
    tools.append(item)  
print(tools) # ["搬砖","菜刀","榔头","AK47","M6"]

  3. 插入，在原列表的指定索引位置插入值

    user_list = ["苍老师","有坂深雪","大桥未久"]
user_list.insert(0,"马蓉")
user_list.insert(2,"李小璐")
print(user_list)
    # 案例
name_list = []
while True:
    name = input("请输入购买火车票用户姓名（Q/q退出）：")
    if name.upper() == "Q":
        break
    if name.startswith("刁"):
        name_list.insert(0, name)
    else:
        name_list.append(name)
print(name_list)

  4. 在原列表中根据值删除（从左到右找到第一个删除）【慎用，里面没有会报错】

    user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.remove("Alex")
print(user_list)


user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:
	user_list.remove("Alex")
print(user_list)


user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
while True:
    if "Alex" in user_list:
        user_list.remove("Alex")
	else:
        break
print(user_list)
    # 案例：自动抽奖程序
import random

data_list = ["iphone12", "二手充气女友", "大保健一次", "泰国5日游", "避孕套"]

while data_list:
    name = input("自动抽奖程序，请输入自己的姓名：")

    # 随机从data_list抽取一个值出来
    value = random.choice(data_list) # "二手充气女友"
    print( "恭喜{}，抽中{}.".format(name, value) )
    
    data_list.remove(value) # "二手充气女友"

  5. 在原列表中根据索引踢出某个元素（根据索引位置删除）

    user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
#               0       1      2      3       4
user_list.pop(1)
print(user_list) #  ["王宝强","Alex","贾乃亮","Alex"]

user_list.pop()
print(user_list) # ["王宝强","Alex","贾乃亮"]

item = user_list.pop(1)
print(item) # "Alex"
print(user_list) # ["王宝强","贾乃亮"]
    # 案例：排队买火车票

# ["alex","李杰","eric","武沛齐","老妖","肝胆"]
user_queue = []

while True:
    name = input("北京~上海火车票，购买请输入姓名排队(Q退出)：")
    if name == "Q":
        break
    user_queue.append(name)

ticket_count = 3
for i in range(ticket_count):
    username = user_queue.pop(0)
    message = "恭喜{},购买火车票成功。".format(username)
    print(message)

# user_queue = ["武沛齐","老妖","肝胆"]
faild_user = "、".join(user_queue) # "武沛齐、老妖、肝胆"
faild_message = "非常抱歉，票已售完，以下几位用户请选择其他出行方式，名单：{}。".format(faild_user)
print(faild_message)

  6. 清空原列表

    user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.clear()
print(user_list) # []

  7. 根据值获取索引（从左到右找到第一个删除）【慎用，找不到报错】

    user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
#               0       1      2       3      4
if "Alex" in user_list:
	index = user_list.index("Alex")
	print(index) # 2
else:
    print("不存在")

  8. 列表元素排序

    # 数字排序
num_list = [11, 22, 4, 5, 11, 99, 88]
print(num_list)
num_list.sort()  # 让num_list从小到大排序
num_list.sort(reverse=True)  # # 让num_list从大到小排序
print(num_list)


# 字符串排序
user_list = ["王宝强", "Ab陈羽凡", "Alex", "贾乃亮", "贾乃", "1"]
#       [29579, 23453, 24378]
#       [65, 98, 38472, 32701, 20961]
#       [65, 108, 101, 120]
#       [49]
print(user_list)
"""
sort的排序原理
    [ "x x x" ," x x x x x " ]
"""
user_list.sort()
print(user_list)

    注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）。

  9. 反转原列表

    user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.reverse()

print(user_list)

12.4.3 公共功能

  1. 相加，两个列表相加获取生成一个新的列表。

    data = ["赵四","刘能"] + ["宋晓峰","范德彪"]
print(data) # ["赵四","刘能","宋晓峰","范德彪"]

v1 = ["赵四","刘能"]
v2 = ["宋晓峰","范德彪"]
v3 = v1 + v2
print(v3) # ["赵四","刘能","宋晓峰","范德彪"]

  2. 相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。

    data = ["赵四","刘能"] * 2
print(data) # ["赵四","刘能","赵四","刘能"]

v1 = ["赵四","刘能"]
v2 = v1 * 2
print(v1) # ["赵四","刘能"]
print(v2) # ["赵四","刘能","赵四","刘能"]

  3. 运算符in包含 由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。

    user_list = ["狗子","二蛋","沙雕","alex"] 
result = "alex" in user_list
# result = "alex" not in user_list
print(result) #  True

if "alex" in user_list:
    print("在，把他删除")
    user_list.remove("alex")
else:
    print("不在")
    user_list = ["狗子","二蛋","沙雕","alex"] 
if "alex" in user_list:
    print("在，把他删除")
    user_list.remove("alex")
else:
    print("不在")

text = "打倒小日本"
data = "日" in text
    # 案例
user_list = ["狗子","二蛋","沙雕","alex"] 
if "alex" in user_list:
    print("在，把他删除")
    user_list.remove("alex")
else:
    print("不在")
    # 案例
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:
	index = user_list.index("Alex")
	user_list.pop(index)
    # 案例：敏感词替换
text = input("请输入文本内容：") # 按时打发第三方科技爱普生豆腐啊；了深刻的房价破阿偶打飞机
forbidden_list = ["草","欧美","日韩"]
for item in forbidden_list:
    text = text.replace(item,"**")
print(text)

    注意：列表检查元素是否存在时，是采用逐一比较的方式，效率会比较低。

  4. 获取长度

    user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( len(user_list) )

  5. 索引，一个元素的操作

    # 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0] )
print( user_list[2] )
print( user_list[3] ) # 报错
    # 改
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
user_list[0] = "武沛齐"
print(user_list) # ["武沛齐","刘华强",'尼古拉斯赵四']
    # 删
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
del user_list[1]

user_list.remove("刘华强")
ele = user_list.pop(1)

    注意：超出索引范围会报错。 提示：由于字符串是不可变类型，所以他只有索引读的功能，而列表可以进行 读、改、删

  6. 切片，多个元素的操作（很少用）

    # 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']

print( user_list[0:2] ) # ["范德彪","刘华强"]
print( user_list[1:] )
print( user_list[:-1] )
    # 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[3:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四']
    # 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']

  7. 步长

    user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
#              0        1        2          3       4
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )
    # 案例：实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]
print(new_data)


data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()
print(data_list)

# 给你一个字符串请实现字符串的翻转？
name = "武沛齐"
name[::-1]

  8. for循环

    user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
	print(item)
    user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]

for index in range( len(user_list) ):
    item = user_index[index]
    print(item)

    切记，循环的过程中对数据进行删除会踩坑【面试题】。

    # 错误方式， 有坑，结果不是你想要的。

user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)
        
print(user_list)


    # 正确方式，倒着删除。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
    item = user_list[index]
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)

12.4.4 转换

  • int、bool无法转换成列表

  • str

    name = "武沛齐"

data = list(name)  # ["武","沛","齐"]
print(data)

  • 超前

    v1 = (11,22,33,44) # 元组
vv1 = list(v1)     # 列表 [11,22,33,44]

v2 = {"alex","eric","dsb"} # 集合
vv2 = list(v2) # 列表 ["alex","eric","dsb"]

12.4.5 其他

12.4.5.1 嵌套

列表属于容器，内部可以存放各种数据，所以他也支持列表的嵌套，如：

data = [ "谢广坤",["海燕","赵本山"],True,[11,22,[999,123],33,44],"宋小宝" ]

对于嵌套的值，可以根据之前学习的索引知识点来进行学习，例如：

data = [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝" ]

print( data[0] ) # "谢广坤"
print( data[1] ) # ["海燕","赵本山"]
print( data[0][2] ) # "坤"
print( data[1][-1] ) # "赵本山"

data.append(666)
print(data) # [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝",666]

data[1].append("谢大脚")
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,22,33,44],"宋小宝",666 ]


del data[-2]
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,22,33,44],666 ]


data[-2][1] = "alex"
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,"alex",33,44],666 ]


data[1][0:2] = [999,666]
print(data) # [ "谢广坤",[999,666,"谢大脚"],True,[11,"alex",33,44],666 ]
# 创建用户列表
#    用户列表应该长： [ ["alex","123"],["eric","666"] ]

# user_list = [["alex","123"],["eric","666"],]
# user_list.append(["alex","123"])
# user_list.append(["eric","666"])


user_list = []
while True:
    user = input("请输入用户名：")
    pwd = input("请输入密码：")

    data = []
    data.append(user)
    data.append(pwd)
    
    user_list.append(data)
user_list = []
while True:
    user = input("请输入用户名(Q退出)：")
    if user == "Q":
        break
    pwd = input("请输入密码：")
    data = [user,pwd]
    user_list.append(data)

print(user_list)

12.5 元组

列表，是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

元组，是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。

12.5.1 定义

# 建议在元组后多加一个逗号
v1=(123,True,["sn","ddh"],)

注意：建议在元组最后加一个逗号，用于标识他是一个元组。

v2=(1)
v3=(1,)
print(v2)
print(v3)
#1
#(1,)

12.5.2 独有功能

无

12.5.3 公共功能

1.相加，两个列表相加获取生成一个新的列表。

v1=("dd","d",)
v2=("dwd","ded",)
print(v1+v2)

2.相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。

v1=("dd","d",)
print(v1*2)

3.获取长度

v1=("dd","d",)
print(len(v1))

4.索引

5.切片

6.步长

4、5、6生成新的数据。

7.for循环

目前只有str,list,tuple可以被for循环。

12.5.4 转换

name="吴佩琦"
data=tuple(name)
print(data)

12.5.5 嵌套

12.6 集合

集合是一个无序，可变，不允许数据重复的容器。

12.6.1 定义

v1={"we","swe"}

  • 无序，无法通过索引取值。

  • 可变，可以添加和删除元素。

v1={"we","swe"}
v1.add("33")
print(v1)

  • 不允许数据重复。

    v1={"we","swe"}
v1.add("33")
print(v1)

    一般什么时候用集合？

    想要维护一大堆不重复的数据时，就可以用它。比如：做爬虫去网上找图片的链接。

注意：定义空集合，只能使用v1=set()，不能使用v={}(这样是定义一个空字典)

v1=set()

12.6.2 独有功能

1.添加元素

v1=set()
v1.add("11")
print(v1)

2.删除元素

v1={"wd","ded","dew"}
v1.discard("wd")
print(v1)

3.交集

v1={"wd","ded","dew"}
v2={"wd","fef","de"}
s1=v1.intersection(v2)
print(s1)

v1={"wd","ded","dew"}
v2={"wd","fef","de"}
s1=v1&v2
print(s1)

4.并集

v1={"wd","ded","dew"}
v2={"wd","fef","de"}
s1=v1.union(v2)
print(s1)

v1={"wd","ded","dew"}
v2={"wd","fef","de"}
s1=v2|v1
print(s1)

5.差集

v1={"wd","ded","dew"}
v2={"wd","fef","de"}
s1=v1.difference(v2)#s1中有，s2中没有
s2=v2.difference(v1)#s2中有，s1中没有
print(s1)
print(s2)

v1={"wd","ded","dew"}
v2={"wd","fef","de"}
s1=v1-v2
s2=v2-v1
print(s1)
print(s2)

12.6.3 公共功能

1.减，计算差值

2.& 计算交集

3.| 计算并集

4.长度

v1={"wd","ded","dew"}
print(len(v1))

5.for 循环

v1={"wd","ded","dew"}
for item in v1:
    print(item)

12.6.4 转换

其他类型想要转换成集合，可以通过set进行转换，数据如果有重复会自动删除。

data="dwdef"
s1=set(data)
print(s1)

data=["sw","sw","wee"]
s1=set(data)
print(s1)

data=("sw","sw","wee")
s1=set(data)
print(s1)
data={"wd","wde"}
v1=list(data)
v2=tuple(data)
print(v1)
print(v2)

12.5.5 其他

12.5.5.1 集合的存储原理

1.先用哈希函数将"学校"转换成一个数值，例如：894234224544

2.取余数(实际掩码做&运算)

894234224544%7=3

3.将其放置3索引的位置

12.5.5.2 元素必须可哈希

内部通过哈希函数把值转换为一个数字。

s1="吴佩琦"
v1=hash(s1)
print(v1)
s2=((11,22,33,))
v2=hash(s2)
print(v2)

目前可哈希的数据类型：int,bool,str,tuple,而list,set是不可哈希的。

12.5.5.3 查找速度特别快

  • 低

    user_list=["we","eer","er"]
if "we" in user_list:
    print("ok")
    
user_list=("we","eer","er")
if "we" in user_list:
    print("ok")

  • 高

    user_list={"we","eer","er"}
if "we" in user_list:
    print("ok")
12.5.5.4 对比和嵌套
类型是否可变是否有序元素要求是否可哈希转换定义空
list是是无否list(其他)v=[]或v=list()
tuple否是无是tuple(其他)v=()或v=tuple()
set是否可哈希否set(其他)v=set()
data_list = [
    "alex",
    11,
    (11, 22, 33, {"alex", "eric"}, 22),
    [11, 22, 33, 22],
    {11, 22, (True, ["中国", "北京"], "沙河"), 33}
]

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：

v1 = {True, 1}
print(v1)  # {True}

v2 = {1, True}
print(v2)  # {1}

v3 = {0, False}
print(v3)  # {0}

v4 = {False, 0}
print(v4)  # {False}

强插：None类型

这个值啥都不是或表示空，相当于其他语言中null作用。

在一定程度上帮我们节省内存。

转为布尔值默认为False。

12.7 字典

字典是无序、键不重复且元素只能是键值对的可变的容器。

在python3.6+字典是有序的，3.6-是无序的。

12.7.1 定义

v1={}
v2=dict()
info={
    "age":12,
    "name":"alex",
    "hobby":["basket","foot"]
}

字典中键值对要求：

  • 键：必须可哈希，(int,bool,str,tuple) 不可哈希(list,set,dict)

  • 值：任意类型

data_list={
    1:29,
    True:5
}
print(data_list)
#{1: 5}

12.7.2 独有功能

1.获取值

info={
    "age":12,
    "name":"alex",
    "hobby":["basket","foot"]
}
data=info.get("age")
print(data)
data1=info.get("email")
print(data1)

2.所有的键

user_info={
    "wupeiqi":123,
    "alex":345,
}
data=user_info.keys()
print(data)
#dict_keys(['wupeiqi', 'alex'])

注意：在python2中，字典.keys()直接获取到的是列表，python3中返回的是高仿列表，此列表可以被循环显示。

3.所有的键值

user_info={
    "wupeiqi":123,
    "alex":345,
}
data=user_info.items()
print(data)

for item in user_info.items():
    print(item)
#item是一个元组(键，值)

user_info={
    "wupeiqi":123,
    "alex":345,
}
data=user_info.items()
print(data)
for item in user_info.items():
    print(item[0],item[1])
    
user_info={
    "wupeiqi":123,
    "alex":345,
}
data=user_info.items()
print(data)
for key,value in user_info.items():
    print(key,value)

4.设置值

data={
    "name":"alex",
    "age":12,
}
data.setdefault("email","123")
print(data)
data.setdefault("name","wpq")
print(data)
#{'name': 'alex', 'age': 12, 'email': '123'}
#{'name': 'alex', 'age': 12, 'email': '123'}

5.更新字典键值对

data={
    "name":"alex",
    "age":12,
}
data.update({"name": "wpq", "age": 14})
print(data)
#没有的键直接增加，有的键更新值

6.移除指定键值对

data={
    "name":"alex",
    "age":12,
}
data.pop("age")
print(data)

7.按顺序移除(后进先出)

data={
    "name":"alex",
    "age":12,
}
res=data.popitem()
print(data)
print(res)
#{'name': 'alex'}
#('age', 12)

py3.6之后，移除最后一个。

py3.6之前，随机移除。

12.7.3 公共功能

1.并集

v1={"k1":1,"k2":2}
v2={"k2":22,"k3":33}
v3=v1|v2
print(v3)
#有键一样则覆盖

2.长度

v1={"k1":1,"k2":2}
print(len(v1))

3.是否包含

info={
    "age":12,
    "name":"alex",
}
v1="age" in info
print(v1)
#等价
v2="age" in info.keys()
print(v2)

4.索引(键)

字典不同于元组和列表，字典的索引是键。

info = { "age":12,  "status":True, "name":"武沛齐"}

print( info["age"] )  	    # 输出：12
print( info["name"] )		# 输出：武沛齐
print( info["status"] )	    # 输出：True
print( info["xxxx"] )   	# 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）

value = info.get("xxxxx") # None
print(value)

  1. 根据键 修改值 和 添加值 和 删除键值对 上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作

   info = {"age":12, "status":True,"name":"武沛齐"}
   
   info["gender"] = "男"
   
   print(info) # 输出： {"age":12, "status":True,"name":"武沛齐","gender":"男"}
   #没有则新增
info = {"age":12, "status":True,"name":"武沛齐"}

info["age"] = "18" 

print(info) # 输出： {"age":"18", "status":True,"name":"武沛齐"}
#有则覆盖
info = {"age":12, "status":True,"name":"武沛齐"}
del info["age"]  # 删除info字典中键为age的那个键值对（键不存在则报错）

print(info) # 输出： {"status":True,"name":"武沛齐"}

  1. for循环

由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；

info = {"age":12, "status":True,"name":"武沛齐"}
for item in info:
	print(item)  # 所有键

12.7.4 转换

v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )

print(v) # { "k1":"v1", "k2":"v2" }

info = { "age":12, "status":True, "name":"武沛齐" }

v1 = list(info)        # ["age","status","name"]

v2 = list(info.keys()) # ["age","status","name"]

v3 = list(info.values()) # [12,True,"武沛齐"]

v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","武沛齐") ]
12.7.4.1 存储原理

image-20240712201829241

12.7.4.2 速度快
info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
for "alex" in info:
    print("在"）
info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")
12.7.4.3 嵌套

  • 字典的键必须可哈希（list/set/dict不可哈希）。

    info = {
    (11,22):123
}

# 错误
info = {
    (11,[11,22,],22):"alex"
}

  • 字典的值可以是任意类型。

    info = {
    "k1":{12,3,5},
	"k2":{"xx":"x1"}
}

  • 集合元组必须可哈希

  • 字典的键必须可哈希

  • 字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况。

  • 元组的元素不可以被替换。

dic = {
	'name':'汪峰',
	'age':48,
	'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],
	'children':['第一个娃','第二个娃']
}
"""
1. 获取汪峰的妻子名字
	d1 = dic['wife'][0]['name']
	print(d1)
2. 获取汪峰的孩子们
	d2 = dic['children']
	print(d2)
3. 获取汪峰的第一个孩子
	d3 = dic['children'][0]
	print(d3)
4. 汪峰的媳妇姓名变更为 章子怡
	dic['wife'][0]['name] = "章子怡"
	print(dic)
5. 汪峰再娶一任妻子
	dic['wife'].append( {"name":"铁锤","age":19} )
	print(dic)	
6. 给汪峰添加一个爱好：吹牛逼
	dic['hobby'] = "吹牛逼"
	print(dic)
7. 删除汪峰的年龄
	del dic['age']
	或
	dic.pop('age')
	print(dic)
"""

12.8 浮点型

浮点型，一般在开发中用于表示小数。

v1 = 3.14
v2 = 9.89

关于浮点型的其他知识点如下：

在项目中如果遇到精确的小数计算应该怎么办？

import decimal

v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3
res="alex"
res1=res.capitalize()
print(res1)
#首字母变大写
v="k1:2"
v1,v2=v.split(":")
print(v1)
print(v2)
#k1
#2

13 代码规范

13.1 名称

  • 文件夹，小写&小写下划线连接，例如community。

  • 文件，小写&小写下划线连接。

  • 变量

    • 全局变量，大写&大写下划线连接。

    • 局部变量，大写&大写下划线连接。

13.2 注释

  • 文件注释

    """
XXX
"""

  • 代码注释

    #XXXX

13.3 todo

image-20240714221944881

13.4 条件嵌套

最好不要超过三层。

13.5 简单逻辑先处理

goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998}
]
for index in range(len(goods)):
    item = goods[index]
    print(index + 1, item['name'], item['price'])

while True:
    num = input("请输入要选择的商品序号(Q/q)：")  # "1"
    if num.upper() == "Q":
        break
    if num.isdecimal():
        num = int(num)
        if 0 < num < 5:
            target_index = num - 1
            choice_item = goods[target_index]
            print(choice_item["name"], choice_item['price'])
        else:
            print("序号范围选择错误")
    else:
        print("用户输入的序号格式错误")

示例2：

goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998}
]
for index in range(len(goods)):
    item = goods[index]
    print(index + 1, item['name'], item['price'])

while True:
    num = input("请输入要选择的商品序号(Q/q)：")  # "1"
    if num.upper() == "Q":
        break
    if not num.isdecimal():
        print("用输入的格式错误")
        break
    num = int(num)

    if num > 4 or num < 0:
        print("范围选择错误")
        break
    target_index = num - 1
    choice_item = goods[target_index]
    print(choice_item["name"], choice_item['price'])

13.6 循环

尽量少循环多干事，提高代码效率。

key_list = []
value_list = []

info = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

for key, value in info.items():
    key_list.append(key)
    value_list.append(value)
info = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

key_list = list(info.keys())
value_list = list(info.values())

13.7 pass

一般Python的代码块是基于 : 和缩进来实现，Python中规定代码块中必须要有代码才算完整，在没有代码的情况下为了保证语法的完整性可以用pass代替，例如：

# 其他编程语言
if 提交{
    ...
}else{
    ....
}
if 条件 :
    pass
else:
    pass

if 条件:
    pass
else:
    pass
for i in range(xxx):
    pass

13.8 is 比较

is 和 ==的区别是什么？

  • ==，用于比较两个值是否相等。

  • is，用于表示内存地址是否一致。

# 示例1
v1 = []
v2 = []

print( v1 == v2 )  # True，两个值相当
print( v1 is v2 )  # False，不属于同一块内存。
# 示例2
v1 = []
v2 = v1

print( v1 == v2 )  # True，两个值相当
print( v1 is v2 )  # True，属于同一块内存。
# 示例3
v1 = None
v2 = None

print(v1 == v2)  # True，两个值相当
print(v1 is v2)  # True，属于同一块内存。

13.9 位运算

计算机底层本质上都是二进制，我们平时在计算机中做的很多操作底层都会转换为二进制的操作，位运算就是对二进制的操作。

  • &，与（都为1）

    a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 

c = a & b         # 12 = 0000 1100

  • |，或（只要有一个为1）

    a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 

c = a | b         # 61 = 0011 1101

  • ^，异或（值不同）

    a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 

c = a ^ b         # 49 = 0011 0001

  • ~，取反

    a = 60            #  60 = 0011 1100 

c = ~a;           # -61 = 1100 0011

  • <<，左移动

    a = 60            #  60 = 0011 1100
c = a << 2;       # 240 = 1111 0000

  • >>，右移动

    a = 60            # 60 = 0011 1101 
c = a >> 2;       # 15 = 0000 1111

平时在开发中，二进制的位运算几乎很好少使用，在计算机底层 或 网络协议底层用的会比较多，例如：

  • 计算 2**n

    2**0    1 << 0   1     1
2**1    1 << 1   10    2
2**2    1 << 2   100   4
2**3    1 << 3   1000  8
...

  • 计算一个数的一半【面试题】

    v1 = 10 >> 1 
print(v1) # 值为5

v2 = 20 >> 1
print(v2) # 值为 10

  • 网络传输数据，文件太大还未传完（websocket源码为例）。

         第1个字节         第2个字节         ... 
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len |    Extended payload length    |
|I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
|N|V|V|V|       |S|             |   (if payload len==126/127)   |
| |1|2|3|       |K|             |                               |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +

FIN位置是0，表示这是一部分数据，后续还有数据。
FIN位置是1，表示这是最后数据，已发送完毕。
    # 例如：接收到的第一个字节的值为245（11110101），让v的二进制和 1000 0000 做 & 与运算。

v = 245   # 245 11110101
          # 128 10000000
                10000000
    
data = v & 128
if data == 0:
    print("还有数据")
else:
    print("已完毕")
偷萧逸苦茶
关注
《Python基础教程》专栏总结篇
weixin_43178406的博客
10-11 18万+
今天给大家带来的文章是《Python基础教程》专栏总结篇，希望能对同学们有所帮助。 文章目录 1. 背景 2. 专栏亮点 3. 你的收获 4. 详细目录
Python 基础（十九）：内置函数大全
水滴的博客
07-27 8854
Python是一种高级编程语言，具有很多强大的特性，其中之一就是内置函数。Python内置函数是指在Python解释器中可以直接使用的函数，无需导入任何模块或库。Python内置函数包含了很多常用的函数，可以快速地完成各种操作。本文将介绍Python内置函数的用法，帮助初学者更好地掌握Python编程。
Python 基础（一）：入门必备知识
热门推荐
Python小二
10-30 116万+
Python 入门必备知识，你都掌握了吗？
Python基础语法——变量
weixin_74093130的博客
10-11 2927
一.Python 语言特点 1.简单易学：与C和Java比，Python的学习难度更低一点，更适合新手入门。 2.简洁明了。Python的语法非常简洁，代码量少，非常容易编写。 3.Python 是解释型语言：开发过程中没有了编译这个环节。类似于PHP和Perl语言。 4.Python 是交互式语言：可以在一个 Python 提示符>>>后直接执行代码。 5.Python 是面向对象语言:Python支持面向对象的风格或代码封装在对象的编程技术。 二.Python基础
Python基础知识点（入门基础知识点）
weixin_43474701的博客
06-01 7812
在 Python 里，标识符有字母、数字、下划线组成。 在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。 Python 中的标识符是区分大小写的。 以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入； 以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函
Python基础
yan_0916的博客
10-11 2万+
目录一.简介二.特点三.基础语法1.编码2.标识符3.python保留字4.注释5.行与缩进 一.简介 Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。 Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。 Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。 Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>&g
【python基础】windows下python环境版本更新教程
任聪聪的博客
03-27 11万+
本篇文章主要讲解python旧版本更新新版本的方法和说明 作者：任聪聪 适用人群：python新手 python更新共有两种常见的可以通过命令行【linux服务器、mac中】和重新安装【windows、mac、linux图形化系统中】进行更新，本次我们只讲解windows下通过安装包进行更新的方法。 通过安装包进行更新 这里我们当前的python版本为3.9 而我们目前需要升级到3.10，所以我们需要先去官网下载 python的官网：https://www.python.org 步骤一、打开并进入官网.
【Python篇】Python基础--Python基本操作
繁依Fanyi的博客
01-06 5896
【Python篇】Python基础–Python基本操作 前言  啦啦啦，现在开始,打算做一期Python基础教程，欢迎大家来看哦！ 导读  这期文章真的是Python基础中的基础，相信有一定编程基础的小伙伴们都一定能看懂的…  本文共分为以下几个部分： 数与运算符 基本输入输出 注释 小彩蛋  如果你还不会，欢迎来玩；如果你会了，可以把滚动条拉到最下面，不妨看看小彩蛋哦！在最后，我将预知未来(懂的估计已经猜到是什么了)… 正文  数与运算符 算数运算符 运算符 描述 例子 +
python基础案例教程课后答案_Python基础案例教程
weixin_39864489的博客
12-09 2779
本书系统地讲述了Python程序设计开发相关基础知识，注重基础、循序渐进、内容丰富、结构合理、思路清晰、语言简练流畅、示例翔实。¥49.00定价：¥49.00/2020-09-01《Python程序设计基础与案例教程》基础部分从0开始，由浅入深，涵盖了Python程序设计的所有基础知识，既适合0基础的学生学习，也适合有一定编程基础的学生学习。第15章的基础综合应用可以提高学生的应用能力，达到学以致...
python基础教程PPT课件.pdf
06-12
python基础教程PPT课件.pdf该文档详细且完整，值得借鉴下载使用，欢迎下载使用，有问题可以第一时间联系作者~
Python基础入门教程 Python语言编程导论 Python应用案例1 （共12页）.ppt
09-25
【Python基础入门教程 Python语言编程导论】课程列表 Python基础入门教程 Python语言编程导论 Python应用案例1 （共12页）.ppt Python基础入门教程 Python语言编程导论 Python应用案例二 （共24页）.ppt Python基础...
python基础教程 第三版 中文 高清 pdf
11-15
第1 章 快速上手：基础知识 1.1 交互式解释器 1.2 算法是什么 1.3 数和表达式 1.4 变量 1.5 语句 1.6 获取用户输入 1.7 函数 1.8 模块 1.8.1 cmath和复数 1.8.2 回到未来 1.9 保存并执行程序 1.9.1 从...
python基础代码大全
07-23
"Python基础代码大全"这个资源集成了许多初学者在学习Python时可能会遇到的基本概念和常见问题的实例代码，旨在帮助他们快速理解和掌握Python编程。 首先，Python的基础语法包括变量定义、数据类型如整型(int)、...
【人工智能学习之PaddleOCR快速上手】
最新发布
Jiagym的博客
10-12 1076
在配置文件中，可以设置组建模型、优化器、损失函数、模型前后处理的参数，PaddleOCR从配置文件中读取到这些参数，进而组建出完整的训练流程，完成模型训练，在需要对模型进行优化的时，可以通过修改配置文件中的参数完成配置，使用简单且方便修改。而 L2 正则化中，添加正则化项的目的在于减少参数平方的总和。准确检测的标准是检测框与标注框的IOU大于某个阈值，正确识别的检测框中的文本与标注的文本相同。如果缺少带标注的数据，或者不想投入研发成本，建议直接调用开放的API，开放的API覆盖了目前比较常见的一些垂类。
文本区域分割系统源码＆数据集分享
lzmlzm89的博客
10-08 1380
数据集信息展示在现代计算机视觉领域，文本区域分割的研究日益受到重视，尤其是在处理文档图像和名片等场景时。为此，我们构建了一个名为“more2”的数据集，旨在为改进YOLOv8-seg模型提供丰富的训练素材，以提升其在文本区域分割任务中的表现。该数据集包含五个类别，具体包括“0”、“2”、“business-name-card”、“doc”和“wendang”，每个类别均具有独特的特征和应用场景，能够为模型的训练提供多样化的样本。
python安装第三方库的问题与解决方法
WANGWUSAN66的博客
10-10 770
大部分第三方库都是在国外网站，如果直接使用pip install 包名，下载速度会很慢，这对一些大型包是很致命的，如果下载中断则需要重头再来。安装某些包时，进行到一半出现构建wheel错误，这可能由于某些神秘的原因造成的，非常让人恼火。有些包（如rasterstats）既不能通过pip安装，在2中的网站也找不到，该怎么办？在python第三方库综合网站上搜索这个包，手动下载whl文件，下载完成后使用。解决方案：使用国内镜像（如清华镜像下载），速度很容易达到1M以上；
RWKV-CHN模型部署教程
SJJS_1的博客
10-10 1158
RWKV-x060-World-7B-v2.1-20240507-ctx4096 一号空间，RWKV 语言模型旨在通过为自动化所有事情来消除使用大型语言模型的障碍。用户所需要的就是一个只有几兆字节的轻量级可执行程序。本文将详细介绍如何实现该模型的本地部署。
micropython中断处理程序设计-临界区
sjh2100的博客
10-08 372
代码的临界区的示例是访问多个变量，这些变量受ISR影响。若中断在对单个变量的访问间发生，则其值将会不一致。这是一种叫作”竞态条件”的问题的实例：ISR和主程序循环争相修改变量。如上所述，若在主代码中修改了Python内置类型的实例或在ISR中访问实例，则应多加注意。执行更改的代码应被视为临界区，以确保ISR运行时实例处于有效状态。这样的IRQ对IRQ（例如，堆可能被锁定）中运行的代码进行了限制，并预定一个稍后会回调的函数能够接触这些限制。在实时系统中，这可能会导致极少的、难以预测的故障。
Python基础入门教程
"python基础教程" 本教程主要涵盖了Python编程语言的基础知识，旨在帮助初学者掌握Python的核心概念。Python是一种高级、解释型、交互式和面向对象的脚本语言，广泛应用于网络爬虫、数据分析、机器学习等多个领域。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值