python基础语法-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_48224700/article/details/144056387

大家一起进步吧！感谢大家的支持和关注,在这里你将了解到全面的python基础知识点

环境就绪

基础语法

代码规范

注释语句

  单行注释 ---> 使用 #
  # 打印结果
  print(123)
  多行注释 ---> 使用双引号和三引号  
  """ 多行注释"""
  '''
  多行注释
  '''

语句和语句间隔

分号为分割符，但是基本不适应，推荐一行一条语句。
换行作为分隔符，推荐

pep8规范

缩进和空格—>四个空格,
行的长度
命名规范—>类用首字母大写的驼峰体命名，其他小写和下划线命名
空行
导入规范
注释
函数和类的定义
代码布局

变量

'''变量是一个标识符，用于引用存储在计算机内存中的数据。每个变量都有一个名称和一个关联的值，可以将值存储在变量中并在程序中多次使用。程序结束，变量销毁'''

# 变量的基本用法
# 1.直接赋值
x= 100
y= 30
# 可以简写
x,y= 100,30
# 变量之间的运算
print(x + y)   # 加
print(x - y)   # 减
print(x * y)   # 乘
print(x / y)   # 除


# 2.修改变量的值
a = 10
# 重新赋值或者叫修改值
a = 11

# 3.变量的传递很重要
b = 1
print(id(b)) # b在内存中的地址
c = b
b = 3
print(id(b)) # b断开指向了另一个地址
print(b)     # 结果是 3

# 交换两个变量值
# 身份互换
role1 = "狼人"
role2 = "预言家"
# 方式一
temp = role1
role1 = role2
role2 = temp
# 方式二
role1,role2 = role2,role1

# 4.表达式赋值
price = 1 + 1
price2 = price + 3
prince2 = price2 +1

命名规范

变量具有描述意义，变量以字母或者下划线开头组合其他字母数字下滑线，不能是关键字
驼峰体 ，多个单词组合，单词的首字母大写
下划线命名，一般用小写字母中间用下划线连接

关键字：列举几个 if else def as del in is or where for pass yield try raise ...

基本数据类型

1.整型和浮点型

整型：表示整数 是一个不可变的类型
浮点型（float）:表示小数
type(对象) 可以获取对象的类型

pi = 3.1415
a = -100
b = 100
print(type(pi))  # pi的类型
print(type(a))
print(type(b))

2.字符串类型

用一对双引号，一对单引号，一对三引号

name = "蜡笔小新"
print(s)
role = '管理员'
print(role)
text = """xxx
ddd
mmm """
print(text)

3.布尔类型

True False
用法

条件判断，是否为真
关系运算符，比较两个值
逻辑运算 and or not
bool（对象）内置函数，将其转换成bool值
零值：都为False
	整型----->0
	浮点型---->0.00
	字符串-----> “”
	布尔 -------->False
	NoneType---> None
	列表-----------> []
	元组-----------> ()
	字典-----------> {}

4.输入输出函数

name  = input("please input your name:")
email = input("please input your email:")
password = input("please input your passsword:")
submit = input("yes or no")
# 输入函数输入的都是字符变量
print(name，type(name))
# 输出函数的参数
print(self，*args, sep="",end="\n",file =None)
# 举个例子就懂了
print(name,email,password,sep="__",end="")
print("progress end")

5.常见的类型转换

# 数字字符串转整型 int(对象)
number = "11"
number = int(number)
print(type(number))
# 整数转字符串 str(对象)
#浮点字符串转浮点型  float(对象)
# 浮点数转字符串 str(对象)

None

常用于表示函数没有返回值或变量尚未被赋值的情况
None 是 NoneType 数据类型的唯一值（其他编程语言可能称这个值为 null、nil 或 undefined）

# print函数默认返回值为None,因为它只用了在屏幕上显示文本，或写入到文本中，不需要返回值。

# 初始化赋值
result = None

运算符

计算运算符

+ - * / % ** //
加减乘除取余幂运算整除(商)

比较运算符

> < >= <= == != 结果为True 或False

赋值运算符

在计算运算符基础上后加了=
x += 1 等价于 x = x+1

逻辑运算符

 and or not 与或非

成员运算符

看看有没有在某个序列中
print(1 in [1,2,3])

运算符优先级

() 最高优先级 建议多使用
** 次高
后面就是先乘除后加减

字符串深入

字符串转义


  `\n`：换行符，表示在字符串中创建一个新行。
  `\t`：制表符，表示在字符串中插入一个水平制（Tab）。
  `\b`：退格字符，b代表backspace，可以把一个退格符看成一个backspace键 `
   \"`：双引号，用于在字符串中包含双引号字符。 
  `\'`：单引号，用于在字符串中包含单引号字符。
  `\\`：反斜杠，用于在字符串中包含反斜杠字符本身

格式化输出

% 占位符

name = "蜡笔小新"
action = "喜欢"
 
game = "游戏"
text= "我是%s%s%s。。。。" %(name,action,game)
print(text) #  我是蜡笔小新喜欢游戏。。。。。

f-string格式 python3.6及以上版本

name = "蜡笔小新"
action = "喜欢"
 
game = "游戏"
text= f"我是{name}{action}{game}。。。。"  
print(text) #  我是蜡笔小新喜欢游戏。。。。。

字符串的索引(index)和切片(slice)

正索引从0开始
负索引最后是-1
start:stop:step
前(start)取后(stop)不取,索引取单值

s = "hello world"
print(s[0]） # "h"
print(s[-1]） # "d"
print(s[0:3]) # "hel"
print(s[::-1]) # "dlrow olleh"
print(s[:]) # "hello world"

其他操作

字符串是不可变类型，不可修改

# 获取长度 len(对象)
s = "hello"
print(len(s)) # 5
# 拼接和复制
s1 = " world"
ss = s + s1 
# ss = s +=s1
print(ss) # "hello world"
sss = s * 3
print(sss) # "hellohellohello"
# in判断
print("o" in s)

内置方法

# (1) 字符串转大写：upper(),字符串转小写：lower()
s = "LaBiXiaoXin"
print(s.upper())  # LABIXIAOXIN
print(s.lower())  # labixiaoxin

# (2) 判断是否以xxx开头
name = "张三"
# 判断是不是姓张
print(name.startswith("张"))

# (3) 判断是否以xxx结尾
url = "/xxx/yyy/zzz/a.png"
print(url.endswith("png"))

# (4) find和index都是查找某子字符串的索引，find找不到返回-1,index找不到报错
print(name.find("三"))
print(name.index("三"))

# (5) 去除两端空格或换行符\n
name = input("请输入姓名:")
print(name, len(name))
name = name.strip()
print(name, len(name))

# (6) 判断某字符串是否全是数字
print("123".isdigit())


# (7) split()和join()
cities = "天津 北京 上海 哈尔滨"
cities_list = cities.split(" ")
print("cities_list", cities_list)
print(len(cities_list))
ret = ",".join(cities_list)
print(ret)  # "天津,北京,上海,哈尔滨

info = "labixiaoxin 19 180"
info_list = info.split(" ")
print(info_list[0]) # "labixiaoxin"
print(info_list[1]) # "19"
print(info_list[2]) #  "180"

# (8) replace(): 子字符串替换
sentence = "PHP is the best language.PHP...PHP...PHP..."
new_sentence = sentence.replace("PHP", "Python")
print(new_sentence)

comments = "这个产品真棒！我非常喜欢。服务很差，不推荐购买。这个餐厅的食物质量太差了，味道不好。我对这次旅行的体验非常满意。这个电影真糟糕，剧情一团糟。这个景点真糟糕，再也不来了！"
comments = comments.replace("差", "***").replace("不推荐", "***").replace("糟糕", "***")
print(comments)

# (9) count:计算字符串中某个子字符串出现的次数
print(sentence.count("PHP"))

流程控制语句

在这里插入图片描述
分支语句

# 双分支语句
if 条件表达式:
  # 条件表达式为True执行的语句块
  # pass 语句可以占位
else:
  # 条件表达式为False执行的语句块
  
# 单分支语句
if 条件表达式:
  # 条件表达式为True执行的语句块
  # pass 语句可以占位

# 多分支语句
if condition1:
    # 当条件1为真时执行的代码块
    pass
elif condition2:
    # 当条件2为真时执行的代码块
    pass
elif condition3:
    # 当条件3为真时执行的代码块
    pass
else:
    # 当所有条件都为假时执行的代码块
    pass

while循环

# while 循环
while 条件：
   循环体
   
# 无限循环
while True:
    print("hello yuan!")

# 有限循环方式1
count = 0  # 初始语句
while count < 10:  # 判断条件
    # print("hello yuan")
    print("count:::", count)
    count += 1  # 步进语句

#有限循环方式2
count = 100  # 初始语句
while count > 0:  # 判断条件
    print("count:::", count)
    count -= 1  # 步进语句

for循环

for 变量 in 容器对象(字符串，列表，字典等)：
   循环体
  
for i in "hello world":
    print(i)  
# range(stop)
# [] 可选参数
# range([start,]stop[,step])

# 打印1到10
for i  in range(1,11)
	print(i)

循环和分支可以相互嵌套
退出循环用break
跳出本次循环用continue

列表

# 里面可以是任何类型数据
game_list = ["Lol","绝地求生","云顶","王者","黎明杀机"]
print(type(game1_list)) # <class 'list'>

'''列表特点
1. 列表中的元素按照顺序进行存储和管理
2. 元素可以是任意类型且可以不一致
3. 元素的长度理论上没有限制
4. 列表允许包含重复的元素
5. 列表是可变数据类型
6. 索引是列表的核心
'''
# 索引查询
print(game_list)
print(gane_list[2]) # 云顶
# 索引修改内容
game[2] = "金铲铲"
# 修改后查询
print(game_list) # ["Lol","绝地求生","金铲铲","王者","黎明杀机"]
# 切片操作
print(game_list[::2]) # ["Lol","金铲","黎明杀机"]
# 修改
game_list[1:3] = ["game1","game2"]
print(game_list) # ["Lol","game1","game2","王者","黎明杀机"]

'''
1、取出的元素数量为：结束位置 - 开始位置；
2、取出元素不包含结束位置对应的索引，列表最后一个元素使用 `list[len(slice)] `获取；
3、当缺省开始位置时，表示从连续区域开头到结束位置；
print(game_list[:3])
4、当缺省结束位置时，表示从开始位置到整个连续区域末尾；
print(game_list[-1:])
5、两者同时缺省时，与列表本身等效；
print(game_list[:])
6、step为正，从左向右切，为负从右向左切
print(game_list[-1:-3:-1])
'''

# 判断成员 in
game_list = ["Lol","绝地求生","云顶","王者","黎明杀机"]
print("LOL" in game_list)   # True
print("game0" in game_list) # False

# 相加
game1_list = ["game6","game7"]
game_list += game1_list
print(game_list) # ["Lol","绝地求生","云顶","王者","黎明杀机","game6","game7"]

# 循环列表（遍历列表）
for game in game_list:
	print(game)

# 打印100次 _
for _ in range(100)
	print("_")

# 计算元素个数 len(对象)
print(len(game_list)) # 7

列表内置方法

game_list = ["Lol","绝地求生"]
# 增
# 列表的最后一个位置
game_list.append("王者") 
print(game_list) # ["Lol","绝地求生","王者"]
# 任意位置增（插）
game_list.insert(0,"game1")
print(game_list) # ["game1"，"Lol","绝地求生","王者"]

# 删
# 默认删最后一个
game_list.pop() 
print(game_list) # ["game1"，"Lol","绝地求生"]
# 指定任意位置删除
game_list.pop(0) 
print(game_list) # ["Lol","绝地求生"]
# 按照元素的值删除
game_list.remove("LOL")
print(game_list) # ["绝地求生"]
# 清空
game_list.clear()
print(game_list) # []
# 合并列表
game_list.extend(["1Lol","3绝地求生","2王者"])
print(game_list) # ["1Lol","3绝地求生","2王者"]
# 排序
game_list.sort()
print(game_list) # ["1Lol","2王者","3绝地求生"]
# 倒序
game_list.reverse()
# 出现个数
n = game_list.count("lol")
print(n) 
# 查看索引
index = game_list.index("2王者")
print(index) # 1

列表的深浅拷贝

先明白可变类型和不可变类型，分清除列表中的可变类型数据和不可变类型数据

浅拷贝

	浅拷贝（Shallow Copy）是创建一个新的列表对象，该对象与原始列表共享相同的元素对象。当你对其中一个列表进行修改时，另一个列表也会受到影响。

# （1）使用切片操作符[:]进行拷贝：
l1 = [1, 2, 3, 4, 5]
l = l1[:]

# （2）使用list()函数进行拷贝
l2 = [1, 2, 3, 4, 5]
l = list(l2)

# （3）使用copy()方法进行拷贝（需要导入copy模块）
l3 = [1, 2, 3, 4, 5]
l = l3.copy()

深拷贝

深拷贝（Deep Copy）是创建一个新的列表对象，并且递归地复制原始列表中的所有元素对象。这意味着原始列表和深拷贝的列表是完全独立的，对其中一个列表的修改不会影响另一个列表。

from copy import deepcopy
origin_list = [1,2,3]
deep_list = deepcopy(origin_list )

深拷贝可能会更耗费内存和时间,尤其是有很多嵌套

列表推导式

'''
new_list = [expression for item in iterable if condition]
`expression` 是要应用于每个元素的表达式或操作。
`item` 是来自可迭代对象（如列表、元组或字符串）的每个元素。
`iterable` 是可迭代对象，提供要遍历的元素。
`condition` 是一个可选的条件，用于筛选出满足条件的元素。
'''

# 筛选出长度大于等于5的字符串
words = ["apple", "banana", "cherry", "date", "elderberry"]
filtered_words = [word for word in words if len(word) >= 5]
print(filtered_words)  # 输出: ["apple", "banana", "cherry"]

元组

不可变类型少了许多列表的功能，又叫只读列表
具体操作长度索引切片成员判断拼接循环查找元素个数和对应索引位置

`字典`

字典的特点：
无序性：字典中的元素没有特定的顺序，不像列表和元组那样按照索引访问。通过键来访问和操作字典中的值。
键是唯一的且不可变类型对象，用于标识值。值可以是任意类型的对象，如整数、字符串、列表、元组等。
可变性：可以向字典中添加、修改和删除键值对。这使得字典成为存储和操作动态数据的理想选择。

字典的创建

# 字典 key-value 这个key操作起来像列表中的索引
info_dict = {"name": "labixiaoxin", "age": 18, "height": 185, "weight": 65} 
print(type(info_dict))  # <class 'dict'>

字典的存储

不要深究
hash 就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数,字典对象的核心其实是个散列表，而散列表是一个稀疏数组(不是每个位置都有值),每个单元叫做bucket,每个bucket有两部分:一个是键对象的引用,一个是值对象的引用，由于,所有bucket结构和大小一致,我们可以通过偏移量来指定bucket的位置

# 定义一个字典
name_dict = {}
# 给键值对，这行第一步就是计算"name"的散列值，python中可以用hash函数得到hash值，再将得到的值放入bin函数，返回int类型的二进制
name_dict["name"] = "labixiaoxin"
# 散列值
print(bin(hash("name")))
# 结果 散列值
-0b100000111110010100000010010010010101100010000011001000011010
# 哈希种子（hash seed）在每次启动都不同，所以你的结果可能和我不同

字典的操作

# 创建空字典
user_dict = {}
user_info = {"name":"labixiaoxin"}

# 查看
print(user_info)
print(user_info["name"])
print(user_info["age"]) # 报错 没有这个键的错误
print(user_info.get("age")) # 不会报错，会返回None

# 添加键值对，存在叫添加，不存在叫修改
user_info["name"] = "labi"
user_info["game"] = "王者荣耀"
user_info["music"] = "青花瓷"

# 删除键值对  删除变量
print(user_info) # {"name":"labi","game":"王者荣耀"，"music":"青花瓷"}
del user_info["game"]
print(user_info) # {"name":"labi", "music":"青花瓷"}
# del user_info
# print(user_info) # 会在内存中删除这个变量，报错

# 成员判断
print("1" in user_info) # False

# 循环
for key in user_info:
	print(key,user_info[key])
# key是不能被修改，只能根据key来修改值

内置方法

user_info = {"name":"labi","game":"王者荣耀"，"music":"青花瓷"}

# (1) 创建字典
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 90)
print(scores) # {'语文': 90, '数学': 90, '英语': 90}

# (2) 获取某键的值
print(user_info .get("name"))  # labi
# (3) 更新键值：添加或更改
gf.update({"age": 18, "weight": "50kg"})
print(gf)  # {'name': 'labi', 'age': 18, 'weight': '50kg',"game":"王者荣耀"，"music":"青花瓷"}

# (4) 删除weight键值对
ret = gf.pop("weight") # 返回删除的值  
print(gf) # {'name': 'labi', 'age': 18, "game":"王者荣耀"，"music":"青花瓷"}

# (5) 遍历字典键值对
for k, v in gf.items():
    print(k, v)
# 可变类型数据 字典 列表

集合

无序，唯一，元素必须为不可变类型

s3 = {1, 2, 3}
# 增删改查
# 增
s3.add(4)
s3.add(3)
print(s3) # {1,2,3,4}
s3.update({3, 4, 5})
print(s3)
# l = [1, 2, 3]
# l.extend([3, 4, 5])
# print(l)
# 删
s3.remove(2)
s3.remove(222)
s3.discard(2)
s3.discard(222)
s3.pop()
s3.clear()
print(s3)  # set()

# 方式1: 操作符 交集(&) 差集(-) 并集(|)
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
print(s1 & s2)  # {3, 4}
print(s2 & s1)  # {3, 4}
print(s1 - s2)  # {1, 2}
print(s2 - s1)  # {5, 6}
print(s1 | s2)  # {1, 2, 3, 4, 5, 6}
print(s2 | s1)  # {1, 2, 3, 4, 5, 6}
print(s1, s2)

# 方式2：集合的内置方法

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
# 交集
print(s1.intersection(s2))  # {3, 4}
print(s2.intersection(s1))  # {3, 4}

# 差集
print(s1.difference(s2))  # {1, 2}
print(s2.difference(s1))  # {5, 6}
print(s1.symmetric_difference(s2))  # {1, 2, 5, 6}
print(s2.symmetric_difference(s1))  # {1, 2, 5, 6}

# 并集
print(s1.union(s2))  # {1, 2, 3, 4, 5, 6}
print(s2.union(s1))  # {1, 2, 3, 4, 5, 6}