「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)
  1. pop:删除最后一个元素
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('‐‐‐‐‐‐删除之前‐‐‐‐‐‐movieName=%s' % movieName)
movieName.pop()
print('‐‐‐‐‐‐删除之后‐‐‐‐‐‐movieName=%s' % movieName)
  1. 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])
  1. 定义只有一个元素的元组,需要在唯一的元素后写一个逗号

切片

  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
  1. del:删除整个字典
info = {'name': 'monitor', 'id': 100}
print('删除前,%s' % info)
del info  # del 也可以直接删除变量
print('删除后,%s' % info)
  1. 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
  1. 遍历字典的value(值)
info = {'name': 'monitor', 'id': 100}
for value in info.values():
    print(value)

# monitor
# 100
  1. 遍历字典的项(元素)
info = {'name': 'monitor', 'id': 100}
for item in info.items():
    print(item)

# ('name', 'monitor')
# ('id', 100)
  1. 遍历字典的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()
  1. 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 异常的类型:
       出现异常以后的处理语句
    
    1. 示例
    try:
        f = open('test.txt', 'r')
        print(f.read())
    except FileNotFoundError:
        print('文件没有找到,请检查文件名称是否正确')
    

你可能感兴趣的:(python,windows,服务器)