当前位置：首页 > 后端开发 > 正文内容

Python根底

邻居的猫1个月前 (12-09)后端开发528

一、数据类型

1. 变量

1.1 界说

  • Python 与其他言语的差异：

    • Python：变量相当于标签

    • 其他言语：变量相当于容器

  • 先赋值后运用

str = "hello"
print(str)

1.2 变量的数据类型

  • 静态类型言语：在运用变量之前界说其数据类型

  • 动态类型言语：在给变量赋值时确认其数据类型，对变量的每一次赋值，都有或许改动变量的类型

【Python 便是动态类型言语】

1.3 检查变量数据类型

  • 语法：type(变量)

  • 能够直接输出，也能够用变量存储成果再输出

  • type()检查的是变量存储的数据的类型，即变量无类型

2. 标识符

  • 由字母、数字、下划线组成，不能以数字最初，且区别大小写（可用中文，但不引荐）

  • 独自的下划线_是一个特别变量，表明上一次运算的成果

  • 见名知意

  • 要害字大写后可作为标识符

>>> 55
55
>>> _+100
155

3. 字面量

  • 在代码中被写下来的固定的值

  • Python 中常用的6种数据类型

类型 描绘 阐明
数字（Number） 支撑：整数、浮点数、复数、布尔 复数：4+3j（以 j 完毕表明复数）
字符串（String） 描绘文本的一种数据类型 由恣意数量的字符组成
列表（List） 有序的可变序列 可有序记载一堆数据（最常用）
元组（Tuple） 有序的不可变序列 可有序记载一堆不可变的数据调集
调集（Set） 无序不重复调集 可无序记载一堆不重复的的数据调集
字典（Dictionary） 无序 Key-Value 调集 可无序记载一堆 Key-Value 型的数据调集

  • 科学计数法

    • e（E）表明以10为底的指数，e 之前为数字部分，之后为指数部分，而两部分有必要一起呈现，指数有必要为整数
45e-5	# 0.00045
  • 复数型数据
a+bJ 或 a+bj

可经过x.real和x.imag来别离获取 x 的实部和虚部，成果都是浮点型

>>> x.real
12.0
>>> x.imag
34.0

4. 转化类型

4.1 为什么

  • 从文件中读取的数字，默许是字符串，需求转化成数字类型

  • input()句子默许成果是字符串，有数字也需求转化

  • 将数字转化成字符串用以写出到外部体系

4.2 常见的转化句子

句子（函数） 阐明
int(x) 转化为整数
float(x) 转化为浮点数
str(x) 将目标 x 转化为字符串

注：浮点数转化为整数时会丢掉精度

二、注释

  1. 单行注释
# 我是单行注释
  1. 多行注释
"""
	我是多行注释
"""
  1. 作业日志阐明：进行没有完结的功用补白
# TODO 阐明文字

三、运算符

1. 算术运算符

  • 根本运算：加、减、乘、除、取余

  • 其他：

    • //：取整除，c **= a等价于c = c ** a

    • **：指数，c //= a等价于c = c // a

2. 链式比较

在 Python 中，能够运用链式比较对多个值进行比较，简化代码

x = 5
print(1 < x < 10)  # 输出 True，相当于 1 < x and x < 10
print(1 < x > 3)  # 输出 True，相当于 1 < x and x > 3
print(1 <= x < 5)  # 输出 False，相当于 1 <= x and x < 5

类似地，比较运算符能够运用等于和不等于运算符确认某些数字是否持平

length = 23
height = 23
width = 6

if length == height and height == width and width == length:
    print("This is a cube")
else:
    print("This is a cuboid")

# 简化代码
if length == height == width:
    print("This is a cube ")
else:
    print("This is a cuboid ")

四、内置函数

BIF（Built-in Functions）：为便利程序员快速编写脚本程序，Python 供给了丰厚的内置函数，如 print()、input() 等

1. input()

  • 语法格局：
name = input()
  • input(提示信息)：输入内容前，输出提示内容
name = input("你是谁？")
print("哦，你是：%s" % name)

注：不管键盘输入什么类型的数据，获取的数据永远都是字符串类型

2. id() 函数

  • 回来指定目标的仅有 id

  • id 是目标的内存地址，而且在每次运转程序时都不同

  • 除了某些具有稳定仅有 id 的目标，比方 -5 到 256 之间的整数

id(object)	# object：任何目标，字符串、数字、列表等等

五、废物收回

  • Python 具有主动内存办理功用，关于没有任何变量指向的值（称为废物数据），体系会主动将其删去

  • 也能够运用 del 句子删去一些目标引证

del x

注：删去变量 x 后，若再运用它，将呈现变量界说过错（name 'x' is not defined）

六、条件分支

if 条件:
	...
elif 条件2:
	...
else:
	...

示例：

if guess == secret:
	print("猜中了！")
else:
	if guess > secret:
		print("猜大了")
	else:
		print("猜小了")

  • 注：

    • 不要忘掉判别条件后的冒号

    • Python 经过缩进判别句子的归属（效果域）

    • input()句子可直接写在条件中

    • 可嵌套运用（要害点：空格缩进）

七、循环结构

1. while循环

while 条件:
	...

示例：

while guess != 8:
	temp = input("猜错了，请从头输入：")
	guess = int(temp)
	
	if guess == secret:
		print("猜中了！")
	else:
		if guess > secret:
			print("猜大了")
		else:
			print("猜小了")

嵌套句子：

while 条件1:
	...
	while 条件2:
	...

留意条件设置，防止形成死循环

2. 弥补常识

2.1 print 输出不换行

默许 print 输出时主动换行，只要在print中加上end = ' '，即可输出不换行

print("hello", end = '')
print("world", end = '')

2.2 制表符 \t

能够完成多行字符串对齐

事例：打印九九乘法表

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

3. for 循环

for 暂时变量 in 待处理数据集（序列）:
	...

示例：遍历字符串

name = "itheima"
# for 循环处理字符串
for x in name:
	print(x)

3.1 阐明

  1. for 循环无法界说循环条件，只能从被处理的数据会集顺次取出内容进行处理

  2. 待处理数据集，严格来说为序列类型【for 循环本质上是遍历序列类型】

  3. 序列类型指：其内容能够一个个顺次取出的一品种型，包含字符串、列表、元组等

  4. for 循环嵌套

3.2 for 循环的变量效果域

  • 若在 for 循环外部拜访暂时变量：

    • 实践：能够拜访

    • 编程标准：不答应、不主张这样做

  • 如需拜访暂时变量，能够预先在循环外界说它

4. continue 和 break

  • continue：中止本次循环，直接进入下一次循环

  • break：直接完毕循环

注：在嵌套循环中，只能效果在地点的循环上，无法对上层循环起效果

八、range 句子

  • 语法格局
range(num1, num2, step)  # 左闭右开

  • 阐明

    • num1：从哪里开端取，省掉默许为 0

    • num2：取到哪里完毕（取不到）

    • step：数字之间的步长，省掉默许为 1

  • 如：

    • range(5)获得的数据是：[0, 1, 2, 3, 4]

    • range(5, 10)获得的数据是：[5, 6, 7, 8, 9]

    • range(5, 10, 2)获得的数据是：[5, 7, 9]

  • 示例：

for x in range(5, 10):
	print(x)

九、函数

1. 根本运用

# 有必要先界说后运用
def 函数名(传入参数):
	函数体
	return 回来值

函数名(参数)
  • 函数的嵌套调用：在一个函数里调用另一个函数

2. None 类型

若函数没有运用 return 回来数据，则函数回来字面量 None 【即函数仍有回来值】

  • 示例：
def say_hi():
	print("hi")

result = say_hi()
print(f"无回来值函数，回来的内容是：{result}")			# None
print(f"无回来值函数，回来的内容类型是：{type(result)}")  # <class 'NoneType'>
  • 能够主动回来 None：
return None

  • None 类型的运用场景

    • 函数无回来值

    • if 判别

      • None 等同于 False

      • 一般用于函数中主动回来 None，合作 if 判别做相关处理

    • 界说变量时暂不需求值时，可用None替代： name = None

3. 阐明文档

给函数增加阐明文档，辅佐了解函数的效果

def func(x, y):
	"""
	函数阐明
	:param x: 形参x的阐明
	:param y: 形参y的阐明
	:return: 回来值的阐明
	"""

  • 经过多行注释对函数进行解说阐明

  • 内容写在函数体之前

4. 变量的效果域

  • 局部变量：效果范围在函数内部

  • 全局变量：在函数内部和外部均可运用

  • 将局部变量声明为全局变量

    • 运用global要害字，能够在函数内部声明全局变量

  • 示例：

num = 100

def testA():
	print(num)

def testB():
	global num
	num = 200
	print(num)

testA()
testB()
print(f"全局变量 num = {num}")

5. 多个回来值

若函数有多个回来值，则依照回来值的次序，写对应次序的多个变量接纳即可，变量之间用逗号离隔，而且支撑不同类型的数据return

def test_return():
	return 1, "hello", True

x, y, z = test_return()
print(x)
print(y)
print(z)

6. 函数参数品种

6.1 方位参数

def user_info(name, age, gender):
	print(f"您的姓名是：{name}, 年纪是：{age}, 性别是：{gender}")
	
user_info('TOM', 20, '男')

注：传递的参数和界说的参数的次序及个数有必要共同

6.2 要害字参数

  • 函数调用时经过key=value办法传递参数

​ 【能够让函数愈加明晰，简略运用，且不必按次序】

def user_info(name, age, gender):
	print(f"您的姓名是：{name}, 年纪是：{age}, 性别是：{gender}")
	
user_info(name = 'TOM', age = 20, gender = '男')
# 可不依照固定次序
user_info(age = 20, name = 'TOM', gender = '男')
# 可与方位参数混用
user_info("小明", age = 20, gender = "男")

注：方位参数有必要在要害字参数前面，但要害字参数之间不存在先后次序

6.3 缺省参数（默许参数）

用于界说函数，为参数供给默许值，调用函数时可不传该默许参数的值

def user_info(name, age, gender='男'):
	print(f"您的姓名是：{name}, 年纪是：{age}, 性别是：{gender}")
	
user_info('TOM', 20)
user_info('Rose', 18, '女')

注：缺省参数要放在最后边

6.4 不定长参数（可变参数）

  • 运用场景：不确认调用时的传参个数（不传参也能够）

  • 不定长参数的类型：① 方位传递 ② 要害字传递

6.4.1 方位传递
def user_info(*args):
	print(args)

user_info('TOM')
user_info('TOM', 18)

注：传进的一切参数都会被args变量搜集，它会依据传进参数的方位兼并为一个元组

6.4.2 要害字传递
def user_info(**kwargs):
	print(kwargs)
	
user_info(name = 'TOM', age = 18, id = 110)

注：一切的 "键 = 值" 都会被 kwargs 接纳，一起依据 "键 = 值" 组成字典

6.4.3 元组和字典的拆包

  • 效果：简化元组变量 / 字典变量的传递

    • 可直接将一个元组变量传递给args

    • 可直接将一个字典变量传递给kwargs

  • 办法

    • 在元组变量前加*

    • 在字典变量前加**

  • 示例：

def demo(*args, **kwargs):
	print(args)
	print(kwargs)
	
# 元组、字典变量
gl_nums = (1, 2, 3)
gl_dict = {"name": "小明", "age": 18}

demo(*gl_nums, **gl_dict)	# 等价于demo(1, 2, 3, "name": "小明", age=18)

7. 函数作为参数传递

  • 将函数传入的效果：传入核算逻辑，而非传入数据

  • 不仅仅是相加、相减、相除等，任何逻辑都能够自行界说并作为函数传入

示例：

def test_func(compute):
	result = compute(1, 2)
	print(f"compute参数的类型是：{type(compute)}")
	print(f"核算成果是：{result}")
	
def compute(x, y):
	return x + y
	
test_func(compute)

8. lambda 匿名函数

lambda 传入参数: 函数体

  • lambda：要害字，表明界说匿名函数

  • 传入参数：匿名函数的形参，如 x, y 表明接纳2个形参

  • 函数体只能写一行代码

  • 匿名函数只能暂时运用一次

示例：

def test_func(compute):
	result = compute(1, 2)
	print(result)

test_func(lambda x, y: x + y)

十、数据容器

  • 意义：一种能够包容多份数据的数据类型，包容的每1份数据称为1个元素，每个元素能够是恣意类型的数据

  • 分类

    • 依据特色不同进行分类，如是否支撑重复元素、是否能够修正、是否有序等

    • 分为5类：列表（list）、元组（tuple）、字符串（str）、调集（set）、字典（dict）

1. 列表（list）

  • 根本语法：
变量名 = [元素1, 元素2, 元素3, ...]

# 界说空列表
变量名 = []
变量名 = list()

注：列表一次可存储多个数据，可为不同的数据类型，支撑嵌套

1.1 索引（下标）

  • 与数组的下标用法共同

  • 能够反向索引，即从后往前：从 -1 开端，顺次递减（-1、-2、-3...）

  • 嵌套列表的下标

    • 用两个中括号，先写外层的下标，再写里层的下标

注：下标不能超出范围

1.2 常用操作

1.2.1 办法
  • 办法和函数功用相同，仅仅运用时格局不同
class Student:
	
	def add(self, x, y):
		return x + y
  • 办法的运用
student = Student()
num = student.add(1, 2)
1.2.2 常用办法
办法 效果
列表.index(元素) 查询某元素的下标，若找不到，报错 ValueError
列表[下标] = 值 修正指定方位的元素值
列表.insert(下标， 元素) 在指定方位刺进指定元素
列表.append(元素)
列表.extend(其他数据容器)		 将指定元素追加到列表尾部
将其他数据容器的内容取出，顺次追加到列表尾部（追加一批数据）
办法1：运用"+"号兼并
办法2：extend办法
办法3：切片
办法4：append办法		 兼并两个列表
语法1：del 列表[下标]
语法2：列表.pop(下标)		 删去某个元素，pop 办法能够将删去元素作为回来值得到
列表.remove(元素) 删去某元素在列表中的第一个匹配项
列表.clear() 清空列表内容
列表.count(元素) 计算某元素在列表内的数量
len(列表) 计算列表内有多少元素
  • 示例：
myList = [1, 2, 3]

# 查询
index = myList.index(2)
print(f"元素2在列表中的下标索引值是：{index}")    # 成果：1

# index = myList.index(4)   # 报错
# print(f"元素4在列表中的下标索引值是：{index}")

# 修正
myList[0] = -1
print(f"列表被修正元素值后，成果是：{myList}")    # 成果：[-1, 2, 3]

# 刺进
myList.insert(1, 6)
print(f"刺进666后的成果：{myList}")    # 成果：[-1, 6, 2, 3]

# 追加
# 办法1：append
myList.append(4)
print(f"append追加单个元素：{myList}")    # 成果：[-1, 6, 2, 3, 4]
myList.append([4, 5, 6])
print(f"append追加列表：{myList}")	# 成果：[-1, 6, 2, 3, 4, [4, 5, 6]]
# 办法2：extend
myList.extend([4, 5, 6])
print(f"extend追加列表：{myList}")	# 成果：[-1, 6, 2, 3, 4, [4, 5, 6], 4, 5, 6]

# 删去
# 办法1：del
del myList[5]
print(f"del删去：{myList}")	# 成果：[-1, 6, 2, 3, 4, 4, 5, 6]
# 办法2：pop
element = myList.pop(0)
print(f"pop删去：{myList}")	# 成果：[6, 2, 3, 4, 4, 5, 6]
# 删去某元素在列表中的第一个匹配项
myList.remove(6)
print(f"remove删去：{myList}")	# 成果：[2, 3, 4, 4, 5, 6]

# 计算某元素在列表内的数量
print(f"count：{myList.count(4)}")		# 成果：2

# 计算列表内有多少元素
print(f"len：{len(myList)}")		# 成果：6

# 清空列表内容
myList.clear()
print(f"清空列表：{myList}")	# 成果：[]
1.2.3 遍历
  • while 循环
index = 0
while index < len(列表):
	元素 = 列表[index]
	对元素进行处理
	index += 1
  • for 循环
for element in my_list:
	print(f"列表的元素有：{element}")

  • 小结：

    • for 循环更简略，while 更灵敏

    • for 用于从容器内顺次取出元素并处理，while 用以任何需求循环的场景

1.3 特色

  • 可包容多个不同类型的元素

  • 有序存储（有下标序号）

  • 答应重复数据存在

  • 可修正

2. 元组（tuple）

  • 当需求在程序内封装数据，又不期望数据被篡改时运用元组

  • 简略了解：元组是只读的列表

  • 元组与列表仅有的不同：不可修正性

2.1 界说

变量名 = (元素1, 元素2, ...)

# 界说空元组
变量名 = ()		# 办法1
变量名 = tuple()	# 办法2

# 界说只要一个元素的元组，后边有必要有逗号，不然就不是元组类型
t = ('hello', )

2.2 相关操作

2.2.1 嵌套
  • 元组内也能够嵌套元组，而且也能够经过下标取出元素
2.2.2 相关操作
办法 效果
index() 查找某个数据，若存在则回来对应下标，不然报错
count() 计算某个数据在当时元组呈现的次数
len(元组) 计算元组内的元素个数
2.2.3 遍历

  • 不能修正元组的内容，不然会报错

  • 可修正元组内嵌套的 list 的内容

t1 = (1, 2, ['itheima', 'itcast'])
t1[2][1] = 'best'
print(t1)		# 成果：(1, 2, ['itheima', 'best'])

3. 字符串

字符串是一个无法修正的数据容器

3.1 根底知道

3.1.1 三种界说办法

  • 单引号

  • 双引号

  • 三引号：name = """ 黑马程序员 """

    • 可完成多行字符串的输出

    • 若不必变量去接纳，则作为多行注释运用

3.1.2 字符串拼接
办法 阐明
经过+拼接 不能和非字符串类型进行拼接
经过,拼接 相邻的两个字符串之间会有空格
空格主动拼接
多行字符串之间会有\主动拼接 拼接后的字符串中心没有空格，不能经过多个变量名来进行多行拼接
经过乘法*进行拼接 一个字符串与n相乘的成果为字符串拼接n次
字符串格局化操作符%拼接
经过str.format()办法拼接
经过str.join()办法拼接 常用来将列表内的字符串拼接成一个大的字符串，列表中的每个元素都需求是字符串类型，str是连接符
经过string模块中的Template目标拼接
经过F-strings拼接 
# ,拼接
from string import Template

print('str1：', 'hello', 'world')

# +拼接
str2 = 'hello' + '12'
print(f"str2：{str2}")

# 空格拼接
str3 = 'hello' 'world'
print(f"str3：{str3}")

# 换行主动拼接
print("str4："
      "hello"
      "world")

# 乘法*拼接
str5 = 'a-' * 10
print(f"str5：{str5}")  # a-a-a-a-a-a-a-a-a-a-

# str.join()
myList = ['你', '好', '世', '界']
str6 = '-'.join(myList)
print(f"str6：{str6}")

# string模块的Template目标
t = Template('${s1} ${s2}！')
str7 = t.safe_substitute(s1='hello', s2='world')
print(f"str7：{str7}")

3.2 字符串格局化

3.2.1 办法1
name = "黑马程序员"
msg1 = "学IT就来%s" % name	# %s是占位符
print(msg1)

# 多个变量要用括号括起来，并依照占位的次序填入
tel = 123456789
msg2 = "我的姓名：%s, 电话：%s" % (name,

扫描二维码推送至手机访问。

版权声明：本文由51Blog发布，如需转载请注明出处。

本文链接：https://www.51blog.vip/?id=163

标签: Python
分享给朋友：
返回列表

上一篇：FLASK蓝本运用初体验，个人对整个构建进程的了解

下一篇：manim边做边学--曲面

“Python根底” 的相关文章

根据 Go + Vue3！一款开源的 Nginx 办理 Web 东西！

根据 Go + Vue3！一款开源的 Nginx 办理 Web 东西！

我们好，我是 Java陈序员。 Nginx 因为其强壮的功用，常常被用于企业开发中！ 今日，给我们介绍一款开源的 Nginx 办理 Web 东西，支撑经过界面完结 Nginx 的装备！ 重视微信大众号：【Java陈序员】，获取开源项目共享、AI副业共享、超200本经典计算机电子书籍等。 项目介绍...

r语言聚类分析,方法、实例与技巧

1. Kmeans聚类：Kmeans是最常用的聚类算法之一，它将数据点分为K个簇，其中K是用户指定的。Kmeans的目标是最小化簇内数据点与簇中心之间的距离。2. 层次聚类：层次聚类是一种将数据点逐层合并或分裂的聚类方法。它构建一个树状结构，称为聚类树或树状图，用于表示数据点之间的相似性。3. 密度...

php关键字, 定义与声明

1. 变量定义： `int`：定义整型变量 `float`：定义浮点型变量 `string`：定义字符串变量 `bool`：定义布尔型变量 `array`：定义数组变量 `object`：定义对象变量 `resource`：定义资源类型变量 `null...

java开源项目,助力开发者高效编程的利器

java开源项目,助力开发者高效编程的利器

1. JavaGuide 提供了丰富的Java开源项目资源，包括框架、工具和教程等，灵感来源于 awesomejava 项目。你可以访问以下链接了解 2. CSDN 上有多篇文章介绍了基于Spring Boot的优质Java开源项目，涵盖了电商、微服务、支付、秒杀、博客、管理后台等多个...

java6,回顾与展望

java6,回顾与展望

Java 6（也称为Java SE 6）是Java编程语言的一个版本，由Sun Microsystems（现为Oracle Corporation）于2006年12月11日发布。Java 6引入了许多新特性和改进，包括但不限于：1. 脚本语言支持：Java 6支持使用脚本语言（如JavaScript...

567go,探索567go——您的智能出行新伙伴

567go,探索567go——您的智能出行新伙伴

567GO国际健身学院成立于2005年，隶属于北京全能奥菲特健身顾问有限公司，是中国知名的健身教育培训企业。学院以团体课程为核心，私人教练培训为重点，致力于为中国健身事业的发展贡献力量。567GO在全国范围内设有多个校区，包括北京、上海、广州、成都、西安、济南、杭州、大连、重庆、长沙、厦门、天津、南...

Copyright © 2024-2028 51blog All Rights Reserved

XML地图