「Python」Python基础

基础语法

字面量

1. 字面量：在代码中被写下来的固定的值
2. 常用值（数据）的类型

类型	描述	说明
数字(Number)	- 整数(int) - 浮点数(float) - 复数(complex) - 布尔(bool)
字符串(String)	描述文本的一种数据类型	程序中需要添加引号
列表(List)	有序的可变序列	Python中使用最频繁的数据类型
元组(Tuple)	有序的不可变序列
集合(Set)	无序不重复集合
字典(Dictionary)	无序Key-Value集合

"""  
字面量  
  
Author：binxin  
Date：2023/10/26 19:20  
"""  
  
666  
13.14  
"黑马程序员"  
  
print(666)  
print(13.14)  
print("黑马程序员")

注释

1. 注释：在程序代码中对程序代码进行解释说明的文字
2. 作用：注释不是程序，不能被执行，只是对程序代码进行解释说明，能够大大增强代码的可读性
3. 分类：
   1. 单行注释:以 # 开头，# 右边 的所有文字当作说明，而不是真正要执行的程序，起辅助说明作用
   2. 多行注释: 以一对三个双引号引起来 (“”“注释内容”“”)来解释说明一段代码的作用使用方法

"""  
注释  
  
Author：binxin  
Date：2023/10/26 19:28  
"""  
  
# 写一个整数字面量  
666  
# 写一个浮点数字面量  
13.14  
# 写一个字符串字面量  
"黑马程序员"  
  
# 通过print语句输出各类字面量  
print(666)  
print(13.14)  
print("黑马程序员")

变量

1. 变量：在程序运行时，能储存计算结果或能表示值的抽象概念
2. 变量的定义格式：变量名称=变量的值

"""
变量

Author：binxin
Date：2023/10/26 19:35
"""

# 定义一个变量，用于记录钱包的余额
money = 50
# 通过print语句，输出变量记录的内容
print("钱包还有：", money)

# 买了一个冰淇淋，花费了10元
money = money - 10
print("买了冰淇凌花了10元，还剩余：", money,"元")

# 假设，每隔一小时，输出一下钱包的余额
print("现在是下午1点，钱包的余额为：",money)
print("现在是下午2点，钱包的余额为：",money)
print("现在是下午3点，钱包的余额为：",money)
print("现在是下午4点，钱包的余额为：",money)

数据类型

1. type()语句
   1. 语法：type(被查看类型的数据)
2. type()语句的使用方式
   1. 在print语句中直接输出类型信息
   2. 用变量存储type()的结果（返回值）
   3. 查看变量中存储的数据类型信息
      1. 查看的是数据的类型，变量无类型

"""
数据类型

Author：binxin
Date：2023/10/27 20:35
"""

# 方式1：使用print直接输出类型信息
print(type("黑马程序员"))
print(type(666))
print(type(11.345))
# 方式2：使用变量存储type()语句的结果
string_type = type("黑马程序员")
int_type = type(666)
float_type = type(11.345)
print(string_type)
print(int_type)
print(float_type)
# 方式3：使用type()语句，查看变量中存储的数据类型信息
name = "黑马程序员"
name_type = type(name)
print(name_type)

数据类型转换

1. 常见的转换语句：都有返回值

语句(函数)	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x)	将x转换为一个字符串

1. 想要将字符串转换成数字，必须要求字符串内的内容都是数字

"""
数据类型转换

Author：binxin
Date：2023/10/27 20:53
"""
# 将数字类型转换为字符串
num_str = str(11)
print(type(num_str), num_str)

float_str = str(11.345)
print(type(float_str), float_str)
# 将字符串转换成数字
num = int("11")
print(type(num), num)

num2 = float("11.345")
print(type(num2), num2)

# 错误示例
# num3 = int("黑马程序员")
# print(type(num3),num3)

# 整数转浮点数
float_num = float(11)
print(type(float_num), float_num)

# 浮点数转整数
int_num=int(11.345)
print(type(int_num),int_num)

标识符

1. 标识符:是用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名
2. 标识符命名规则
   1. 内容限定：只允许使用英文、中文、数字、下划线
      1. 不推荐使用中文
      2. 数字不能做开头
   2. 大小写敏感：字母的大写和小写，是完全能够区分的
   3. 不可使用关键字
3. 变量的命名规范
   1. 见名知意
   2. 下划线命名法：多个单词组合变量名，要使用下划线做分隔
   3. 英文字母全小写

"""
标识符

Author：binxin
Date：2023/10/28 19:13
"""

# 内容限定
# 错误的代码示范
# 1_name = "张三"
# name_ != "张三"

name_ = "张三"
_name = "张三"
name_1 = "张三"

# 大小写敏感
Itheima = "黑马程序员"
itheima = "666"
print(Itheima, itheima)

# 不可使用关键字
# 错误示例
# class =1
# def =1
Class = 1

运算符

1. 算术（数学）运算符

运算符	功能
+	加
-	减
*	乘
/	除
//	取整除
%	取余
**	指数

1. 赋值运算符：=
2. 复合赋值表达式

"""
运算符
Author：binxin
Date：2023/10/28 19:27
"""

# 算术(数学)运算符
print("1+1=", 1 + 1)
print("2-1=", 2 - 1)
print("3*3=", 3 * 3)
print("4/2=", 4 / 2)
print("11//2=", 11 // 2)
print("9%2=", 9 % 2)
print("2**2=", 2 ** 2)

# 赋值运算符
num = 1 + 2 * 3

字符串扩展

字符串的三种定义方式

1. 单引号定义法：name = ‘黑马程序员’
2. 双引号定义法：name = “黑马程序员”
3. 三引号定义法：name = “”“黑马程序员”“”
4. 字符串的引号嵌套
   1. 单引号定义法，可以内含双引号
   2. 双引号定义法，可以内含单引号
   3. 可以使用转移字符 \ 来将引号解除效用，变成普通字符串

# 单引号定义法
name = '黑马程序员'
print(type(name), name)
# 双引号定义法：
name = "黑马程序员"
print(type(name), name)
# 三引号定义法
name = """
黑马
程序员
"""
print(type(name), name)

# 在字符串内包含双引号
name = '"黑马程序员"'
print(type(name), name)
# 在字符串内包含单引号
name = "'黑马程序员'"
print(type(name), name)
# 使用转义字符 \ 接触引号效用
name = "\"黑马程序员\""
print(type(name), name)
name = '\'黑马程序员\''
print(type(name), name)

字符串拼接

1. 如果我们有两个字符串(文本)字面量，可以将其拼接成一个字符串，通过+号即可完成

# 字面量之间的拼接
print("pin" + "hsin")

# 字符串字面和和字符串变量之间的拼接
name = "pinhsin"
point = "学python"
print("我是" + name + "，我在" + point)

字符串格式化

1. 多个变量占位变量要用括号括起来，并按照占位的顺序填入

# 通过占位的形式完成拼接
name = "黑马程序员"
message = "学IT来：%s" % name
print(message)

# 通过占位的形式，完成数字和字符串的拼接
class_num = 57
avg_salary = 16781
message = "Python大数据学科，北京%sq期，毕业平均工资：%s" % (class_num, avg_salary)
print(message)

1. 语法：f"内容{变量}"
   1. 不限数据类型，不做精度控制

格式化的精度控制

1. 使用辅助符号"m.n"来控制数据的宽度和精度
   1. m：控制宽度，要求是数字(很少使用)，设置的宽度小于数字自身，不生效
   2. .n：控制小数点精度，要求是数字，会进行小数的四舍五入

对表达式进行格式化

1. 表达式：一条具有明确执行结果的代码语句
2. 格式化同字符串格式化

数据输入

1. input()语句
   1. 括号内可以填入提示内容

"""
数据输入

Author：binxin
Date：2023/11/10 14:21
"""
name = input("请告诉我你是谁？")
print("我知道了，你是%s" % name)

# 输入数字类型
num = input("银行卡密码：")
print(type(num))  # 
# 数据类型转换
num = int(num)
print(type(num))

数据类型进阶

列表

添加元素

1. append：在末尾添加元素

#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("‐‐‐‐‐添加之前，列表A的数据‐‐‐‐‐A=%s" % A)
#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
A.append(temp)
print("‐‐‐‐‐添加之后，列表A的数据‐‐‐‐‐A=%s" % A)

1. insert(index, object)：在指定位置index前插入元素object

strs = ['a','b','m','s']
strs.insert(3,'h')
print(strs)  # ['a', 'b', 'm', 'h', 's']

1. extend：通过extend可以将另一个列表中的元素逐一添加到列表中

a = ['a','b','c']
b = ['d','e','f']
a.extend(b)
print(a)  # ['a', 'b', 'c', 'd', 'e', 'f'] 将 b 添加到 a 里
print(b) # ['d','e','f'] b的内容不变

修改元素
通过指定下标来访问列表元素，因此修改元素的时候，为指定的列表下标赋值即可

#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("‐‐‐‐‐修改之前，列表A的数据‐‐‐‐‐A=%s" % A)
#修改元素
A[1] = 'xiaoLu'
print("‐‐‐‐‐修改之后，列表A的数据‐‐‐‐‐A=%s" % A)

查找元素

1. in（存在）,如果存在那么结果为true，否则为false
2. not in（不存在），如果不存在那么结果为true，否则false

#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
#获取用户要查找的名字
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in nameList:
	print('在列表中找到了相同的名字')
else:
	print('没有找到'

删除元素

1. del：根据下标进行删除

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('‐‐‐‐‐‐删除之前‐‐‐‐‐‐movieName=%s' % movieName)
del movieName[2]
print('‐‐‐‐‐‐删除之后‐‐‐‐‐‐movieName=%s' % movieName)

2. pop：删除最后一个元素

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('‐‐‐‐‐‐删除之前‐‐‐‐‐‐movieName=%s' % movieName)
movieName.pop()
print('‐‐‐‐‐‐删除之后‐‐‐‐‐‐movieName=%s' % movieName)

3. remove：根据元素的值进行删除，只会删除第一个相同的元素

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('‐‐‐‐‐‐删除之前‐‐‐‐‐‐movieName=%s' % movieName)
movieName.remove('指环王')
print('‐‐‐‐‐‐删除之后‐‐‐‐‐‐movieName=%s' % movieName)

元组

1. Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号
2. 访问元组

tuple = ('hello', 100, 3.14)
print(tuple[0])
print(tuple[1])
print(tuple[2])

3. 定义只有一个元素的元组，需要在唯一的元素后写一个逗号

切片

1. 切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作
2. 语法：[起始:结束:步长]，也可以简化使用 [起始:结束]
   1. 选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔

# 索引是通过下标取某一个元素
# 切片是通过下标去某一段元素
s = 'Hello World!'
print(s)
print(s[4])  # o 字符串里的第4个元素
print(s[3:7])  # lo W 包含下标 3，不含下标 7
print(s[1:])  # ello World! 从下标为1开始，取出 后面所有的元素（没有结束位）
print(s[:4])  # Hell 从起始位置开始，取到 下标为4的前一个元素（不包括结束位本身）
print(s[1:5:2])  # el 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）

字典

查看元素
除了使用key查找数据，还可以使用get来获取数据

info = {'name': '班长', 'age': 18}
print(info['age'])  # 获取年龄
# print(info['sex']) # 获取不存在的key，会发生异常
print(info.get('sex'))  # 获取不存在的key，获取到空的内容，不会出现异常
print(info.get('sex', '男'))  # 获取不存在的key, 可以提供一个默认值。

修改元素
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

info = {'name': '班长', 'id': 100}
print('修改之前的字典为 %s:' % info)    # 修改之前的字典为 {'name': '班长', 'id': 100}:
info['id'] = 200  # 为已存在的键赋值就是修改
print('修改之后的字典为 %s:' % info)    # 修改之后的字典为 {'name': '班长', 'id': 200}:

添加元素
如果在使用 变量名['键'] = 数据 时，这个“键”在字典中不存在，那么就会新增这个元素

info = {'name': '班长'}
print('添加之前的字典为:%s' % info)  # 添加之前的字典为:{'name': '班长'}
info['id'] = 100  # 为不存在的键赋值就是添加元素
print('添加之后的字典为:%s' % info)  # 添加之后的字典为:{'name': '班长', 'id': 100}

删除元素

1. del：删除指定的元素

info = {'name': '班长', 'id': 100}
print('删除前,%s' % info)  # 删除前,{'name': '班长', 'id': 100}
del info['name']  # del 可以通过键删除字典里的指定元素
print('删除后,%s' % info)  # 删除后,{'id': 100

2. del：删除整个字典

info = {'name': 'monitor', 'id': 100}
print('删除前,%s' % info)
del info  # del 也可以直接删除变量
print('删除后,%s' % info)

3. clear：清空整个字典

info = {'name': 'monitor', 'id': 100}  
print('清空前,%s' % info)  
info.clear()  
print('清空后,%s' % info) # 清空后,{}

字典的遍历

1. 遍历字典的key（键）

info = {'name': 'monitor', 'id': 100}
for key in info.keys():
    print(key)

# name
# id

2. 遍历字典的value（值）

info = {'name': 'monitor', 'id': 100}
for value in info.values():
    print(value)

# monitor
# 100

3. 遍历字典的项（元素）

info = {'name': 'monitor', 'id': 100}
for item in info.items():
    print(item)

# ('name', 'monitor')
# ('id', 100)

4. 遍历字典的key-value（键值对）

info = {'name': 'monitor', 'id': 100}
for key, value in info.items():
    print(f'key={key},value={value}')

# key=name,value=monitor
# key=id,value=100

文件

文件的打开与关闭

打开文件/创建文件

1. 在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
2. 语法：open(文件路径，访问模式)

f = open('test.txt', 'w')

访问模式

访问模式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，则报错。这是默认模式
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入
r+	打开一个文件用于读写。文件指针将会放在文件的开头
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
ab+	以二进制格式打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写

关闭文件

# 新建一个文件，文件名为:test.txt
f = open('test.txt', 'w')
# 关闭这个文件
f.close()

文件的读写

写数据(write)

f = open('test.txt', 'w')  
f.write('hello world, i am here!\n' * 5)  
f.close()

读数据

1. read：使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入 num，那么就表示读取文件中所有的数据

f = open('test.txt', 'r')  
content = f.read(5) # 最多读取5个数据  
print(content)  
print("‐" * 30) # 分割线，用来测试  
content = f.read() # 从上次读取的位置继续读取剩下的所有的数据  
print(content)  
f.close() # 关闭文件

如果用 open 打开文件时，如果使用的" r "，那么可以省略 open('test.txt')

1. readline：只用来读取一行数据

f = open('test.txt', 'r')  
content = f.readline()  
print("1:%s" % content)  
content = f.readline()  
print("2:%s" % content)  
f.close()

1. readlines：可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行为列表的一个元素

f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
for temp in content:
    print(temp)
f.close()

序列化和反序列化

• 序列化：对象->字节序列
• 反序列化：字节序列->对象

使用JSON实现序列化

1. dumps：把对象转换成为字符串，它本身不具备将数据写入到文件的功能

import json

file = open('names.txt', 'w')
names = ['zhangsan', 'lisi', 'wangwu', 'jerry', 'henry', 'merry', 'chris']
# file.write(names)  出错，不能直接将列表写入到文件里
# 可以调用 json的dumps方法，传入一个对象参数
result = json.dumps(names)
# dumps 方法得到的结果是一个字符串
print(type(result))  # 
# 可以将字符串写入到文件里
file.write(result)
file.close()

2. dump：可以在将对象转换成为字符串的同时，指定一个文件对象，把转换后的字符串写入到这个文件里

import json

file = open('names.txt', 'w')
names = ['zhangsan', 'lisi', 'wangwu', 'jerry', 'henry', 'merry', 'chris']
# dump方法可以接收一个文件参数，在将对象转换成为字符串的同时写入到文件里
json.dump(names, file)
file.close()

使用JSON实现反序列化

1. loads：需要一个字符串参数，用来将一个字符串加载成为Python对象

import json

# 调用loads方法，传入一个字符串，可以将这个字符串加载成为Python对象
result = json.loads('["zhangsan", "lisi", "wangwu", "jerry", "henry", "merry", "chris"]')
print(type(result))  # 

1. load：可以传入一个文件对象，用来将一个文件对象里的数据加载成为Python对象

import json

# 以可读方式打开一个文件
file = open('names.txt', 'r')
# 调用load方法，将文件里的内容加载成为一个Python对象
result = json.load(file)
print(result)
file.close()

异常

1. 在读取一个文件时，如果这个文件不存在，则会报出FileNotFoundError错误

2. try…except语句

   1. 语法

   try:
      可能会出现异常的代码块
   except 异常的类型:
      出现异常以后的处理语句
   

   2. 示例

   try:
       f = open('test.txt', 'r')
       print(f.read())
   except FileNotFoundError:
       print('文件没有找到,请检查文件名称是否正确')