Conda虚拟环境装到D盘,而不是C盘

conda create --prefix D:\programming_software\conda_env\your_env_nanme python=3.12

Python 通常被归为解释型语言,但它并不是“纯解释”。更准确地说,Python 是 “先编译成字节码,再由解释器执行” 的语言。

.py 源代码

↓

编译成字节码 .pyc 字节码

↓

由 Python 虚拟机 PVM 解释执行 运行结果

所以 Python 的运行过程是:

  1. 解释器先把 .py 源代码编译成 字节码 bytecode;
  2. 字节码通常缓存在 __pycache__ 目录下的 .pyc 文件里;
  3. Python 虚拟机 PVM 再逐条解释执行这些字节码。71115

因为它最终不是直接生成操作系统能跑的机器码 .exe,而是依赖解释器/虚拟机执行,所以一般仍把它叫作 解释型语言。

编译型 vs 解释型

维度编译型语言解释型语言
执行方式先整体编译成机器码,再运行边解释边执行
典型语言C、C++、Go、RustPython、JavaScript、Ruby
运行速度通常更快通常更慢
跨平台性差,需要针对不同平台重新编译好,只要有对应解释器即可运行
调试开发修改后需重新编译修改后可直接运行,调试方便
错误发现编译阶段能发现较多错误运行到对应代码时才发现错误

一句话记忆

编译型像“提前把整本书翻译成机器码”,解释型像“同声传译,边读边翻”。
Python 介于两者之间:内部会编译成字节码,但最终仍由解释器执行,所以通常称为解释型语言。

命名规则

大驼峰(PascalCase / CapWords)

例如:MyName、UserProfile、HTTPServerError

主要适用于:

  • 类名(最核心用途)
  • 异常类名

小驼峰(camelCase / mixedCase)

例如:myName、userName

在 Python 中基本不推荐使用。

小驼峰(mixedCase)仅允许在已有旧代码风格需要保持兼容时使用,新项目应避免。

字符串占位符

方法1:%占位符

name = "张三"
age = 18
# %s,%d是表示数据类型的占位符,里面的内容可以用变量来填充
# 变量按照顺序填写即可
print('我的名字是%s,今年%d岁。'%(name,age))

方法2:字符串的format方法

name = "张三"
mobile = "12345678901"
# 调用字符串的一个函数(方法),format,把后面两个变量传入左边的参数列表
print('姓名:{},联系方式:{}'.format(name,mobile))

方法3:format方法的简写形式

在Python3.6以后版本,为了简化format输出操作,引入了一个简写形式:

name = "张三"
mobile = "12345678901"
# 开头加f,{}里面写变量名
print(f'姓名:{name},联系方式:{mobile}')

break与continue

在Python循环中,经常会遇到两个常见的关键词:break 与 continue

break:代表终止整个循环结构

continue:代表中止当前本次循环,继续下一次循环

for循环中的else结构

循环可以和else配合使用,else下方缩进的代码指的是当循环正常结束之后要执行的代码。

强调:'正常结束'。 当非正常结束时,其else中的代码时不会执行的。(如遇到break的情况)

        str2是正常循环完,else里面的那句话打印

        str1 有e,break了,没正常循环完,,else里面的这句话不打印

有break

str1 = 'itheima'
str2 = 'ithaima'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        break
    print(i)
else:
    print('循环正常结束,没有break后打印这行代码')

用continue

contunue跳过了这次循环还是算完整跑完了循环,else里面这句话会显示出来

str1 = 'itheima'
str2 = 'ithaima'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        continue
    print(i)
else:
    print('循环正常结束,没有break后打印这行代码')

打印结果

i
t
h
遇到e不打印
i
m
a
循环正常结束,没有break后打印这行代码

字符串里面的引号

单引号里面再用个单引号,加 左上右下斜杆

str1 = 'I\'m Tom'
str2 = "I'm Tom"
print(str1)

在计算机中,Python中的字符串属于序列结构。所以其底层存储占用一段连续的内存空间。

字符串的操作

find查找字符串中一个元素的索引

user_file_name = input('请输入一个文件名称:')
index= user_file_name.find('.')
print(f"您输入的文件名:{user_file_name},对应的扩展名点的索引是{index}")

有就返回索引

请输入一个文件名称:winnerwinnerchickendinner.exe
您输入的文件名:winnerwinnerchickendinner.exe,对应的扩展名点的索引是25

如果没有返回-1

请输入一个文件名称:what?
您输入的文件名:what?,对应的扩展名点的索引是-1

index 找不到会报错

image_str = 'avatar.png'
index = image_str.index('z')
Traceback (most recent call last):
  File "code_lab\py_basic\01.py", line 39, in <module>
    index = image_str.index('z')
            ^^^^^^^^^^^^^^^^^^^^
ValueError: substring not found

找到了,返回索引

image_str = 'avatar.png'
index = image_str.index('r')
print(f"您输入的文件名{image_str}中字母'r'的索引是{index}")

replace替换字符串

字符串.replace(要替换的内容, 替换后的内容, 替换的次数-可以省略)

省略替换次数,为替换全部

str1 = 'hello linux, love linux, conquer linux'

print(str1.replace('linux','java',2))

split()字符串拆分方法

按某一个字符,把他拆分

str2 = 'apple-banana-pear'
print(str2.split('-'))

需求: 请将str2中每一个单词的首字符变更为大写

words= str2.split('-')
# capitalize() 就是把字符串的 第一个字母变大写,其余字母变小写。
result = [w.capitalize() for w in words]
print(result)

用字符串 把列表拼接起来join()方法

fruits_list= ['apple', 'banana', 'orange']
print("&".join(fruits_list))
apple&banana&orange

字符串首字母大写

print('apple'.title())
print('pear'.capitalize())
Apple
Pear

五大容器

列表在计算机中的底层存储形式,列表和字符串一样,在计算机内存中都占用一段连续的内存地址,我们向访问列表中的每个元素,都可以通过"索引下标"的方式进行获取。

列表list

index查找元素的位置索引

list1 = [1, 2, 3, 1, 3, 'a', 'b', 2, 'b', 1]
print(list1.index('b'))
6

查询某个元素出现的次数

list1 = [1, 2, 3, 1, 3, 'a', 'b', 2, 'b', 1]
print(list1.count(1))
3

插入数据

编号函数作用
1append()增加指定数据到列表中
2extend()列表结尾追加数据,如果数据是一个序列,则将这个序列的数据逐一添加到列表
3insert()指定位置新增数据
# 1- 定义一个列表
list1 = ['张三','李四','王五','赵六']

list1.append('田七')


# 2.2 定义一个新的列表 列表中有 周八和李九  帮我添加到list1中
list2 = ['周八','李九']

list1.extend(list2)

# 2.3 请帮我在列表的头部 和 列表的第三个位置添加数据
list1.insert(0,'老张')

list1.insert(2,'老李')

删除元素

编号函数作用
1del 列表[索引]删除列表中的某个元素
2pop()删除指定下标的数据(默认为最后一个),并返回该数据 (删除+取出)
3remove()移除列表中某个数据的第一个匹配项。
del list1[5]

# 根据元素删除: 删除 田七
list1.remove('田七')  # 当该元素不存在的时候, 会直接报错

reverse反转列表

列表顺序直接反转

# 反转列表
list2=[1, 2, 3, 1, 3, 'a', 'b', 2, 'b', 1]
list2.reverse()
print(list2)
[1, 'b', 2, 'b', 'a', 3, 1, 3, 2, 1]

不要直接打印 list.reverse() 是 原地修改,它直接改列表本身,不返回新列表,所以返回值是 None

# 反转列表
list2=[1, 2, 3, 1, 3, 'a', 'b', 2, 'b', 1]
print(list2.reverse())
None

元组tuple

元组可以存储多个数据且元组内的数据是不能修改的。

集合 set

集合(set)是一个无序的不重复元素序列。

① 天生去重

② 无序

集合的增操作

add()方法:向集合中增加一个元素(单一)

☆ 集合的删操作

remove()方法:删除集合中的指定数据,如果数据不存在则报错。

字典 dict

无

推导式

[元素  从什么中来]

my_list = [i for i in range(1,10)]

两层嵌套循环

result = [(x, y) for x in [1, 2] for y in ['a', 'b']]
print(result)
[(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]

等价于

变量名 = []
for 变量1 in 列表1:
    for 变量2 in 列表2:
        变量名.append(表达式)

函数

我们使用函数的目的只有一个“让我们的代码可以被重复使用”

变量的作用域

在函数内部定义范围就称之为局部作用域,在函数外部(全局)定义范围就是全局作用域

        全局作用域定义的变量,函数内容和外部都能调用

str1 = 'hello'
# 定义一个函数
def func():
    # 在函数内部调用全局变量str1
    print(f'在局部作用域中调用str1变量:{str1}')

# 直接调用全局变量str1
print(f'在全局作用域中调用str1变量:{str1}')
# 调用func函数
func()

局部变量:在函数的调用过程中,开始定义,函数运行过程中生效,函数执行完毕后,销毁

# 定义一个函数
def func():
    # 在函数内部定义一个局部变量
    num = 10
    print(f'在局部作用域中调用num局部变量:{num}')
​
# 调用func函数
func()
# 在全局作用域中调用num局部变量
print(f'在全局作用域中调用num局部变量:{num}')
Traceback (most recent call last):
  File "D:\code_lab\py_basic\01.py", line 78, in <module>
    print(f'在全局作用域中调用num局部变量:{num}')
                                            ^^^
NameError: name 'num' is not defined. Did you mean: 'sum'?

Process finished with exit code 1

global关键字的应用场景

使得局部变量,可以修改全局变量

# 定义全局变量num = 10
num = 10
# 定义一个函数func
def func():
    # 尝试在局部作用域中修改全局变量
    global num
    num = 20

# 调用函数func
func()
# 尝试访问全局变量num
print(num)

首先区分,对容器赋值操作和容器内数据修改操作的区别。

对容器赋值操作,让my_list指向一个新的地址,实际是一个新的容器了

my_list = [1, 2, 3]
# 地址就变了
my_list = [9, 9, 9]

容器内数据修改操作,还是原来那个容器,只不过里面装的东西有了变动

my_list = [1, 2, 3]
my_list.append(182)
# [1, 2, 3, 182]

如果你仅仅是修改容器内的数据,函数内就可以修改全局变量,没必要加global

my_list = [1, 2, 3]

def reset_list():
    # 错误!这会创建一个全新的局部变量 my_list,外部的列表不受影响
    # my_list = [9, 9, 9]

    # 正确!想要重新赋值整个列表,必须加 global
    my_list.append(182)

reset_list()
print(my_list)  # 输出: [9, 9, 9]
[1, 2, 3, 182]

如果你是想换个容器,让变量名指向一个新的容器,用global

my_list = [1, 2, 3]

def reset_list():
    # 错误!这会创建一个全新的局部变量 my_list,外部的列表不受影响
    # my_list = [9, 9, 9]

    # 正确!想要重新赋值整个列表,必须加 global
    global my_list
    my_list = [9, 9, 9]

reset_list()
print(my_list)  # 输出: [9, 9, 9]
[9, 9, 9]

但是你注意,刚刚的这个 加不加global的情况适用分别,仅仅适用于 可变类型(列表、字典、集合),一旦你面对的是不可变数据类型(数值、字符串、布尔类型、元组类型),就必须global

        因为这一部分数据不可修改,只能重新数据,指向新的地址

关键字传参

可以在传参的时候写     形参=实参  传入

def user_info(name, age, address):
    print(f'我的名字{name},今年{age}岁了,家里住在{address}')
    
# 调用函数(使用关键词参数)
user_info(name='Tom', age=23, address='美国纽约')    #  关键词参数

位置传参和关键字传参混用

位置参数必须写在关键词参数前面 ,否则报错

        某种程度上,一旦混用,关键字传参也变成形参了,只不过标明了这个位置参数的  对应的形参关键字是什么

def greet(name, age):   # ← 这是形参定义,跟这条规则无关
    print(f"你好{name},我的年龄是{age}")
    
# greet("Alice", age=25)   # ✅ 正确
greet(name="Alice", 25)  # ❌ 语法错误

按照位置识别形参和实参之间的对应关系的是 位置参数

        按顺序,一一对应

def user_info(name, age, address):
    print(f'我的名字{name},今年{age}岁了,家里住在{address}')
    
# 调用函数
user_info('Tom', 23, '美国纽约')    #  位置参数

根据调用时候,写明这个实参传给哪个形参的,叫关键词参数

def user_info(name, age, address):
    print(f'我的名字{name},今年{age}岁了,家里住在{address}')
    
# 调用函数(使用关键词参数)
user_info(name='Tom', age=23, address='美国纽约')    #  关键词参数

不定长参数

不定长元组(位置)参数 *

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。

        接受多个参数,实际上传入不只是固定的几个参数了,变成元组这个容器了

def show(*args):
    for index,values in enumerate(args):
        print(index,values)
# 传参也行
show("a","b","c")
# 不传参,也行,都不会报错
show()

可以使用元组的索引来访问*args的每个元素

def user_info(*args):       #   arguments : 参数   可以是其他变量名
    # print(args)  # 元组类型数据,对传递参数有顺序要求
    print(f'我的名字{args[0]},今年{args[1]}岁了,住在{args[2]}')

# 调用函数,传递参数
user_info('Tom', 23, '美国纽约')

不定长字典(关键字)参数 **

def user_info(**kwargs):   #  keyword  arguments : 关键字参数   可以是其他变量名
    # print(kwargs)  # 字典类型数据,对传递参数没有顺序要求,格式要求key = value值
    print(f'我的名字{kwargs["name"]},今年{kwargs["age"]}岁了,住在{kwargs["address"]}')

# 调用函数,传递参数
user_info(name='Tom', address='美国纽约', age=23)

总结:

  • 一个星号 * ↔ 打包位置参数 ↔ 元组 tuple

  • 两个星号 ** ↔ 打包关键词参数 ↔ 字典 dict

Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐