python如何快速入门 python快速入门精讲

转载

mob64ca13faa4e6 2024-01-11 21:45:37

文章标签 python如何快速入门 python 字符串 Python 数据 文章分类 Python 后端开发

前言

接上次安装好Python的第三方库并且成功运行之后
准备深入的读懂代码
直接读感觉有点枯燥
并且需要直接查的模块的有点多（其实是连Main方法，输入输出都找不到）
所以感觉还是需要快速过一下B站上一些基础教程
做一个大概的了解
这篇博客也算给自己做一个简单的记录

1.关于Python的基础

1.1 编译器与解释器

编译器/解释器就是一个将代码翻译成计算机能够识别的命令。

解释器，实时翻译。拿到代码后，解释一句交给操作系统一句。《Python,PHP,JS,Ruby…… 一般称为解释型语言》
编译器，全文翻译。拿到代码后，编译成一个临时文件（计算机能够识别命令），再把文件交给操作系统读取。《C,C++,GO,Java…… 一般称为编译型语言》
两者没有优劣之分
注：常说Python的解释通常指的是CPython解释器。默认Python解释器是以UTF-8编码打开的。

1.2 输出

默认输出自带换行

print(" ")

如果想不换行，需要这样

print(" ",end="")

1.3 数据类型

1. 整形（ int ）

2. 字符串（ str ）

如果字符串中需要有双引号，则将print括号内两边变单引号。""" “”" 三引号用于多行字符串（三个单引号意义一样）
对于字符串：
加，两个字符串可以通过加好拼接起来。

print("grit"+"666")

乘，可以让整形和字符串进行相乘，以实现让字符串重复出现N次并拼接起来。

print(2*"6")

3. 布尔类型（bool）

True / False 在转换成整形后 true == 1 ， False == 0。
整形跟字符串无法比较大小，可以比较是否相等。

4.类型转换

遵循一个基本准则：想转换什么类型，就让他包裹一些。
例：

str(666)="666"
#将整形转换为字符串
int("888")
#将字符串转整形

整形转换成布尔类型时，除了 0 是False，其它都是True。

bool(1)  #true
	bool(-19) #true
	bool(0)   #false

字符串转换成布尔类型时，除了 ""是False，其它都是True。

bool("grit")  #true
	bool("666")   #true
	bool("")      #false
	bool(" ")     #true

1.4 变量

变量只能由字母、数字、下划线组成。
不能以数字开头
不能以Python内置的关键字
建议：
下划线连接命名
见名知意

1.5 注释

单行注释

#单行注释   快捷键为 CTRL + ?

多行注释

"""
	多行注释
	多行注释
	"""

1.6 输入

#输入
	name = input()
	name = input(" 请输入 ：")

特别注意：用户输入的本质上都是当做字符串处理。

1.7 条件语句

if…else

#单条件
if 条件:
    条件成立之后的代码
    ...
else:
   条件不成立之后的代
   ...

提醒：统一缩进问题（一般都是四个空格）。

#多条件
if 条件A:
	A条件成立之后的代码
	...
else 条件B:
   B条件成立之后的代码
   ...
else 条件C:
   C条件成立之后的代码
   ...
else :
	ABC都不成立

#多条件嵌套
if 条件A:
	if 条件A1:
	...
	else:
	...

while 循环

while 条件:
	...
	...
	...

# break ,用于在While循环中终止循环
while 条件:
	...
	...
	break
	...#代码不执行

# continue , 在循环中用于 结束本次循环，开始下一次循环
while 条件:
	...
	...
	continue
	...#代码不执行,回到while开头

# while...else ，当while后条件不成立时，else中的代码就会执行。
while 条件:
	...
else:
	...

1.8 字符串格式化

字符串格式化，使用更便捷的形式实现字符串的拼接。
1.%

name = "grit"
age =  20
#  %s 字符串占位符  %d整形占位符
text = "我是%s" %name
text = "我是%s,今年%s岁"%(name,age)
text = "%(steam_id)s 登录了。" %{"steam_id":"grit"} #给占位符命名
text = "%(steam_id)s 登录了%(steam_game)。" %{"steam_id":"grit","steam_game":"CS:GO"} #给多个占位符命名

注意：在对于存在百分比的语句，需要占位符，将百分比后边再加一个%即可避免报错。

format(推荐)

text = "我是{0}，今年20岁".format("grit")
text = "我是{0}，今年{1}岁".format("grit",20)
text = "我是{0}，今年{1}岁，真实姓名是{0}".format("grit",20)#复用
#可以简写成如下，效果一样：
text = "我是{}，今年20岁".format("grit")
text = "我是{}，今年{}岁".format("grit",20)
text = "我是{}，今年{}岁，真实姓名是{}".format("grit",20,"grit")#不能复用

text = "我是{n1}，今年20岁".format(n1="grit")
text = "我是{n1}，今年{age}岁".format(n1="grit",age=20)
text = "我是{n1}，今年{age}岁，真实姓名是{n1}".format(n1="grit",age=20)

text = "我是{n1}，今年{age}岁"
data1=text.format("grit",20)
data2=text.format("niko",21)

f(Python 3.6版本之后，更便捷)

game = "CS:GO"
text = f"我喜欢玩{game}"

game = "CS:GO"
years = 5
text = f"我喜欢玩{game},{years}年了"

# 进制转换
v1=f"我今年{20}岁"
v1=f"我今年{20:#b}岁"  #转换为2进制
v1=f"我今年{20:#o}岁"  #转换为8进制
v1=f"我今年{20:#x}岁"  #转换为16进制

#f 可以直接执行函数
name = "grit"
text = f"我是{name.upper()}"  #转换成大写

1.9 运算符

int a = 10
	int b = 20

算数运算符

python如何快速入门 python快速入门精讲_字符串

比较运算符

python如何快速入门 python快速入门精讲_字符串_02

赋值运算

python如何快速入门 python快速入门精讲_数据_03

成员运算

python如何快速入门 python快速入门精讲_Python_04

逻辑运算
优先级

加减乘除 > 比较 > not>and>or
实在拿不准就加括号。

1.10 进制和编码

1.10.1 进制

Python中 10 进制是以整型形式存在的

2 8 16 进制是以 字符串形式存在的

之间的转换关系如下：

python如何快速入门 python快速入门精讲_字符串_05

v1 = bin(66) #十进制转换为二进制
v2 = oct(66) #十进制转换为八进制
v3 = hex(66) #十进制转换为十六进制

int("XXX",base = X)#将X进制的XXX 转换为十进制

1.10.2 单位

b(bit)，位
B（byte），字节
KB（kilo byte），千字节
MB
G
T

1.10.3 编码

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

ASCII编码（基础）
规定使用1个字节来表示字母与二进制的对应关系。所以一共2*8个=256。
GB-2312 编码（不常用）
由国家信息标准委员会制作。GBK编码，对GB2312进行拓展，包含中日韩等文字。
在与二进制做对应关系时，由如下逻辑：
单字节表示，用一个字节表示对应关系。
双字节表示，用两个字节表示对应关系。
unicode （万国码）

Ucs2
用固定的2个字节去表示一个文字 2*16 = 65535
Ucs4
用固定的4个字节去表示一个文字 2*32
无论是UCS2 UCS4都有缺点：浪费空间
unicode的应用：在文件存储和网络传输时，不会直接使用unicode，而在内存中会用unicode。

UTF-8 （应用最为广泛的编码）
本质上：是对Unicode的压缩，用尽量少的二进制去与文字进行对应。一般中文都是用第三个模板（3个字节）。
Python 相关的编码

字符串（str）  " grit 666"                 unicode处理              一般是在内存
字节（byte）   b"dadsadawedawxz"         utf-8编码 or gbk编码       一般用于文件或网络处理

将字符串转换成字节

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

2.数据类型详解

字典，列表，字符串（用的多）

2.1 整形

2.1.1 定义

age = 10
number = 99

2.1.2 独有功能

无

2.1.3 公共功能

加减乘除

2.1.4 转换

#布尔型
n1 =  int (True)     #True 转换为1 

#字符串类型
v1 = int ("ob1001",base = 2) #把字符串看成二进制的值，然后在转换为 十进制整数，结果 v1=186

# 浮点型（小数）
v1 = int(8.7)     #8

2.1.5 其它

python 2 中有长整形和整形
python 3 中只有整形

py3地板除得到准确值
py2底板处得到接近的整数值

v1= 9/2
#py3 v1 = 4.5
#py2 v1 = 4

2.2 布尔类型

2.2.1 定义

data = Falese

2.2.2 独有功能

无

2.2.3 公共功能

无

2.2.4 转换

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

2.2.5 其它

做条件自动转换

如果在if , while 条件后面写一个值当条件时，他会默认转换为布尔类型，在做条件判断。

2.3 字符串

2.3.1 定义

v1 = "Grit"

2.3.2 独有功能(18/48)

"xxx".功能()

v1= "xxx"
v1.功能()

判断字符串是否以XX开头，得到一个布尔值

v1.startswith("XX")

判断字符串是否以XX结尾头，得到一个布尔值

v1.endswith("XX")

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

resulet = v1.isdecimal()
print(result)

去除字符串两边的空格、换行符（\n）、制表符(\t)、得到一个新字符串

msg = "  he l l o "
data = msg.strip()   #去除两边空白
data = msg.lstrip()  #去除左边空白
data = msg.rstrip()  #去除右边空白

补充：去除字符串两边指定的内容

data = msg.strip("a")   #去除两边a
data = msg.lstrip("a")  #去除左边a
data = msg.rstrip("a")  #去除右边a

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

msg = "grit"
data = msg.upper()

print(msg)  #grit
print(data) #GRIT

注意是得到一个新的字符串

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

msg = "GRIT"
data = msg.lower()

print(msg)  #GRIT
print(data) #grit

注意是得到一个新的字符串

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

data = "你是个好人，但是好人不适合我"
value = data.replace("好人","男人")
print (data) # "你是个好人，但是好人不适合我"
print (value) #"你是个男人，但是男人不适合我"

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

data = "Grit|root|NB|bbb"
result = data.split("|")

print (result)  #输出["Grit","root","NB","bbb"]
result[0] = "Grit"
result[1] = "root"

result = data.split("|",2)# 从左往右，切2 

result = data.rsplit("|",2)# 从右往左，切2

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

data_list = ["grit","B","A"]
v1 = "*".join(data_list)#"grit*B*A"
v2 = "".join(data_list)#"gritBA"

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

text = "我是{0}，今年20岁".format("grit")
text = "我是{0}，今年{1}岁".format("grit",20)
text = "我是{0}，今年{1}岁，真实姓名是{0}".format("grit",20)#复用
#可以简写成如下，效果一样：
text = "我是{}，今年20岁".format("grit")
text = "我是{}，今年{}岁".format("grit",20)
text = "我是{}，今年{}岁，真实姓名是{}".format("grit",20,"grit")#不能复用

text = "我是{n1}，今年20岁".format(n1="grit")
text = "我是{n1}，今年{age}岁".format(n1="grit",age=20)
text = "我是{n1}，今年{age}岁，真实姓名是{n1}".format(n1="grit",age=20)

text = "我是{n1}，今年{age}岁"
data1=text.format("grit",20)
data2=text.format("niko",21)

字符串转换为字节类型

data = "嫂子"  #unicode  #字符串类型
v1 = data.encode("utf-8")  # utf-8 字节类型

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

v1 = "Grit"
data = v1.center(2,"*")  #"*Grit*"
data = v1.ljust(2,"*")   # "Grit**"
data = v1.rjust(2,"*")   # "**Grit"

Zfill 帮助填充 0 应用场景：处理二进制数据

data ="grit"
v1 =data.zfill(8) #"0000grit"

2.3.3 公共功能

相加：“字符串+字符串” （拼接）
相乘：“字符串”*整数（几倍）
长度：len(data)
获取字符串中的字符，索引

message = "来点活"
print(message[0]) #"来"
print(message[1])
print(message[2])

print(message[-1])#"活"

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

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

message = "aabaa"
print(message[0:2]) aab
print(message[2:])baa
print(message[:3])aaba

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

name ="生活不止眼前的苟且，还有诗和远方的田野。"

print(name[0:5:2])  #输出：生不跟【前两个值表示区间范围，最后一个值表示步长】
print(name[:8:2])  #输出：生不眼的且【区间范围的前边不写则表示起始范围从0开始】
print(name[0::3])  #输出：生止的,诗方野【区间范围的后边不写则表示结束范围为最后】
print(name[::3])  #输出：生止的,诗方野【区间范围不写表示整个字符串】
print(name[2:1:-1])  #输出：不活【倒叙】

循环

while循环
for循环

messgae = "Grit"
for char in message:
     print(char)

range,帮我们创建一系列数字（列表形式）
for + range

for i in range(5):#[0,1,2,3,4]
print(i)

一般应用场景：

while ，一般在做无限制（未知）循环处时使用。
for ,一般应用在已知的循环数量的场景。
都可以应用break和continue。

2.3.4 转换

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

2.3.5 其它

字符串不可被修改

2.4 列表

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

2.4.1 定义

user_list = ["ak","m4","awp"]
data_list = ["ak","2700"]
data_list.append("awp")
print(data_list)#ak , 2700 ,awp

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

2.4.2 独有功能

追加

data_list.append()

批量追加，将一个列表中的元素逐一添加到另一个列表

tools=["a","b","c"]
tools1=["1","2"."3"]
tools.extend(tools1) # a,b,c,1,2,3

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

user_list =  ["niko","zywoo","simple"]
user_list.insert(0,"ropz")#ropz,niko,zywoo,simple
user_list.insert(2,"device")#ropz,niko,zywoo,device,simple

在源列表中根据值删除（从左到右找到第一个删除）【慎用，里边没有会报错】解决办法，先判断，再删除。

user_list =  ["niko","zywoo","simple"]
user_list.remove("simple")

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

user_list.pop()  #不填写默认踢出最后一个
user_list.pop(2)  #踢出指定位置
data = user_list.pop(2) #可以将制定踢出值 赋值给其它变量

清空原列表

user_listy=.claer()

根据值获取索引（从左到右找到第一个删除）【慎用，里边没有会报错】解决办法，先判断，再删除。

rank  = user_list.index("niko") # 1

列表元素排序从小到大排序

#数字排序
num_list=[4,3,2,1,5,6,7]
num_list.sort()  #1，2，3，4，5，6，7 
num_list.sort(reverse = True)  #从大到小排

#字符串排序  
user_list =  ["niko","zywoo","simple"]
user_list.sort()

字符串排序是将字符串的每一个字符转换至Unicode 码典，然后再进行比较。
注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）

反转原列表

user_list = ["niko","zywoo","simple"]
user_list.reverse()

2.4.3 公共功能

相加
将两个列表拼接。得到新列表
相乘
列表*整形将列表中的元素在创建N份并生成一个新的列表
运算符 in 包含
由于列表内部是由多个元素组成，可以通过in来判断是否在列表中

user_list = ["niko","zywoo","simple"]
result =  "niko"  in  user_list
result =  "niko"  not in  user_list

获取长度

user_list = ["niko","zywoo","simple"]
len(user_list)

索引（单个元素）

#读
user_list[0]
#改
user_list[0] = "simple"
#删
del user_list[0]

切片（多个元素）
也可以进行读改删
步长
for循环
注意：千万不要在循环的过程中，边循环获取列表的数据，边删除列表的数据。解决方案，倒着处理。

2.4.4 转换

int、 bool 无法转换成列表
str

name =  " grit"
data= list(name)

超前

v1 = (11,12,13) #元组
vv1 = list(v1)

v2= {"alex","dsb"."asc"}#集合
vv2 = list(v2)

2.4.5 其它

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

data = ["谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝"]
print (data[0]) # 谢广坤
print (data[1]) #["海燕","赵本山"]
print (data[0][2])# "坤"
print (data[1][-1]) # "赵本山"

2.5 元组

2.5.1 定义

有序，则不可变的容器，在里边可以存放多个不同类型的元素。

v1 = (11,22,33)
v2 = ("李杰","alex")
v3 = ("true",True)

注意：建议在元组的最后多加一个都厚，用于标识他是一个元组。

2.5.2 独有功能

无

2.5.3 共有功能

相加，两个列表相加获取生成一个新的列表。
相乘，列表*整形，将列表中的元素在创建N分并生成一个新的列表。
获取长度
索引
切片
步长
For 循环

2.5.4 转换

其它类型转换为元组，使用tuple(其它类型)，目前只有字符串和列表可以转换为元组。

2.5.5嵌套

由于元组和列表都可以充当容器，他们内部可以放很多元素，并且也支持元素内的嵌套。

2.6 集合

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

2.6.1 定义

v1={11,22,33,"alex"}

无序，无法通过索引取值
可变，可以添加和删除元素
不允许数据重复
一般什么时候用集合？
就是需要维护一大堆不重复的数据时，就可以用。
注意：定义空集合时，只能用 v = set()，不能用v={}(这样是定义一个空字典)

2.6.2 独有功能

添加元素

data = set()
data.add("GRE")
data.add("TOFFU")
data.add("CET")

删除元素

data.doscard("CET")

交集

s1 = {"1","2"."3"}
s2 = {"2"."4"}

s4 =  s1.intersection(s2)
s3 = s1 & s2      #简单表述（简写）

并集

s5 = s1.union(s2) 
s5 = s1 | s2 #简单表述（简写）

差集

s6 = s1.difference(s2)     #差集，s1中有且s2中没有的值
s6 = s1 - s2               #差集，简写

2.6.3 公共功能

减，计算差集
&，计算交集
| ，计算并集
长度

v= {"2","8"}
data =  len(v)

for 循环

v = {"1","2","3"}
for item in v:
	print (item)

2.6.4 转换

其它类型如果想要转换集合类型，可以通过set 进行转换，并且如果数据有重复自动剔除。
提示：Int\list\tuple\dict 都可以转换成集合

v1  = "adaddwa"
v2 = set (v1)

2.6.5 其它

集合的元素必须可哈希。
目前可以哈希的数据类型：int 、bool、 str 、 tuple(元组)，而 list 、set（集合）是不可哈希的。所以，集合的元素只能是：int 、bool、 str 、 tuple(元组)。
集合的查找速度特别快
因存储原理特殊，集合的查找效率非常高（数据量大了才明显）
对比和嵌套

注意：由于 True 和 False 本质上存储的是1 和 0，而集合又不允许重复。

2.5 None

None 意味着这个值啥都不是或表示为空，和其它语言中 NULL 作用一样。
在一定程度上可以帮助我们省去内存。
所以None 在布尔类型中表示 False。

2.6 字典（dict）

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

data = {"k1":1,"k2":2}  #冒号前面是键，后面是值。

容器
元素必须键对
键不重复，重复会被后面覆盖
在Python 3.6 以后是有序，之前是无序。

2.6.1 定义

v1 = {}
v2 = dict{}

data = {
	"k1" : 1
	"k2" : 2
}

info  =  [
	"age" : 12,
	"name": "grit",
	"score": 470	
}

字典中对键值得要求：

键：必须可哈希，目前可以哈希的数据类型：int 、bool、 str 、 tuple(元组)，而 list 、set（集合）、dict（字典）是不可哈希的。
值：任意类型

一般什么时候用字典？
当我们想要表示一组固定信息时，用字典可以更加直观

2.6.2 独有功能

获取值

info  =  [
	"age" : 12,
	"name": "grit",
	"score": 470	
}
data = info.get{"age"}

写代码准则：简单的逻辑放在前面，复杂的逻辑放在后面。

获取所有的键

info  =  [
	"age" : 12,
	"name": "grit",
	"score": 470	
}
data = info.keys()

获取所有的值

info  =  [
	"age" : 12,
	"name": "grit",
	"score": 470	
}
data = info.values()

所有的键值

info  =  [
	"age" : 12,
	"name": "grit",
	"score": 470	
}
data = info.items()

设置值

info  =  [
	"age" : 12,
	"name": "grit",
	"score": 470	
}
data = info.setdefault("add",30)

更新字典键值对

data = info.update("add",30)

移除制定键值对

data = info.pop("add",30)

按照顺序移除

data = info.popitem()

py3.6之后移除最后一个值。
py2.6之前随机移除一个值。

2.6.3公共功能

求并集 | （py3.9新加入）
长度
是否包含
索引（键）
字典不同于元组和列表，字典索引的是键，而列表和元组则是 0 、 1、 2 等数值。
根据键修改值和添加值和删除键值对
通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作
for 循环
由于字典也属于容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；

2.6.4 转换

想要转换为字典

V = dict ()

2.6.5 其它

速度快
字典的键必须可哈希（list\set\dict不可哈希）
字典的值可以是任意类型的
集合元素必须可哈希（list\set\dict不可哈希）
字典的键必须可哈希（list\set\dict不可哈希）
字典的键和集合的元素遇到布尔值 0.1时需要注意重复的情况。
元组的元素不可以被替换。

2.7 浮点型（float）

在类型转换时需要，在浮点转换为整形时，会将小数部分去掉。
可以保留小数点后N位

v1 = 3.1415926
result = round (v1,N)

浮点型在计算的时候，会不是精确计算。（坑）

3.总结和补充

简单的逻辑先处理，复杂的逻辑后处理。
尽量少循环，多干事。
PASS
一般python的代码块是基于缩进和：来实现的，Python 中规定代码块中必须要有代码才算完整，在没有代码的情况下，为了保证语法的完整性，可以用PASS代替。
is 和 ==
== 用于表示两个值是否相等。
is 用于标识内存地址是都一致。
位运算
& ，与（二进制都1 则1）
| ，或（二进制有1 则1）
^ , 异或（二进制不同则1）
~ ，取反（二进制取反）
<< , 左移（二进制向左移两位）

，右移（二进制向右移动两位）

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：微信开发者签名微信jssdk签名

下一篇：Docker 搭建api docker 搭建nifi集群

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯