初学者的Python基本语法笔记

Sonder

2023-04-26

13426字

34分钟

浏览 (1.6k)

一些python算法

算出素数

复制代码

for n in range(2,100):
   for x in range(2,n):
       if n % x == 0:
           print(n,'=',x,'*',n//x)
           break;
   else:
       print(n,'是一个素数')

获取0-3下标的数组

复制代码

list = [1,3,5,'撒大苏打']
ss = list[:3]
print(ss) #[1, 3, 5]

将华氏温度转换为摄氏温度

复制代码

f = float(input('请输入华氏温度: '))
c = (f - 32) / 1.8
print('%.1f华氏度 = %.1f摄氏度' % (f, c)) # %.1f是浮点数保留一位小数，并四舍五入
# print(f'{f:.1f}华氏度 = {c:.1f}摄氏度')

输入半径计算圆的周长和面积

复制代码

radius = float(input('请输入圆的半径: '))
perimeter = 2 * 3.1416 * radius
area = 3.1416 * radius * radius
print('周长: %.2f' % perimeter)
print('面积: %.2f' % area) # %.2f是浮点数保留两位小数，并四舍五入

判断输入的边长能否构成三角形，如果能则计算出三角形的周长和面积

复制代码

a = float(input('a = '))
b = float(input('b = '))
c = float(input('c = '))
if a + b > c and a + c > b and b + c > a:
   print('周长: %f' % (a + b + c))
   p = (a + b + c) / 2
   area = (p * (p - a) * (p - b) * (p - c)) ** 0.5
   print('面积: %f' % (area))
else:
   print('不能构成三角形')

输出乘法口诀表

复制代码

for i in range(1, 10):
   for j in range(1, i + 1):
       print('%d*%d=%d' % (i, j, i * j), end='\t')
   print()

只输出s的前20个字符，而不是所有字符

复制代码

s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
num = 1
for item in s:
   if num > 20:
       break
   print(item)
   num = num + 1

假如希望输出字符串s中第10个以后的字符，而不是所有字符，这个时候，我们可以使用continue跳过前面的9个字符。

复制代码

s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
num = 1
for item in s:
   if num < 10:
       num = num + 1
       continue
   print(item)
   num = num + 1

请综合使用while和continue，计算0~1000以内，所有偶数的和。

复制代码

num = 0
sum = 0
while num <= 1000:
   num = num + 1
   if num % 2 == 1:
       continue
   sum = sum + num
print(sum)

找出字典（对象）里面value大于100的

复制代码

stocks = {
   'AAPL': 191.88,
   'GOOG': 1186.96,
   'IBM': 149.24,
   'ORCL': 48.44,
   'ACN': 166.89,
   'FB': 208.09,
   'SYMC': 21.29
}
stocks2 = {key: value for key, value in stocks.items() if value > 100}
print(stocks2) #{'AAPL': 191.88, 'GOOG': 1186.96, 'IBM': 149.24, 'ACN': 166.89, 'FB': 208.09}

字符串

替换文案format

请使用两种format的方式打印字符串Life is short, you need Python。

复制代码

print('Life is short, you need {}'.format('Python'))
print('Life is short, you need {launguage}'.format( launguage = 'Python'))

拼接字符串/清除前后空格

复制代码

# 清除前后空格或字符串类型
sss= '    asdasdasdas     '.strip()
# 拼接字符串
a = f"""
{sss}1111
"""

常用方法

复制代码

str1 = 'hello,world!'
# 通过内置函数len计算字符串的长度
print(len(str1)) # 13
# 获得字符串首字母大写的拷贝
print(str1.capitalize()) # Hello, world!
# 获得字符串每个单词首字母大写的拷贝
print(str1.title()) # Hello, World!
# 获得字符串变大写后的拷贝
print(str1.upper()) # HELLO, WORLD!
# 从字符串中查找子串所在位置
print(str1.find('or')) # 8
print(str1.find('shit')) # -1
# 与find类似但找不到子串时会引发异常
# print(str1.index('or'))
# print(str1.index('shit'))
# 检查字符串是否以指定的字符串开头
print(str1.startswith('He')) # False
print(str1.startswith('hel')) # True
# 检查字符串是否以指定的字符串结尾
print(str1.endswith('!')) # True
# 将字符串以指定的宽度居中并在两侧填充指定的字符
print(str1.center(50, '*'))
# 将字符串以指定的宽度靠右放置左侧填充指定的字符
print(str1.rjust(50, ' '))
str2 = 'abc123456'
# 检查字符串是否由数字构成
print(str2.isdigit())  # False
# 检查字符串是否以字母构成
print(str2.isalpha())  # False
# 检查字符串是否以数字和字母构成
print(str2.isalnum())  # True
str3 = '  jackfrued@126.com '
print(str3)
# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())

容器List

列表(list)是一种有序的容器，放入list中的元素，将会按照一定顺序排列。

查看/排序

复制代码

# 一个数字的列表
my_numbers = [10, 8, 3, 7, 11]
# 升序，按升序对列表进行就地排序
my_numbers.sort()
# 打印修改后的列表
print(my_numbers)#[3, 7, 8, 10, 11]

# 降序，从大到小
my_numbers.sort(reverse=True) #[11, 10, 8, 7, 3]

循环

复制代码

# 里面的 0 意思就是从下标0开始
for index, item in enumerate(resultlist, 0):

添加（append、insert）

append

append()方法总是将元素添加到list的尾部

复制代码

names = ['Alice', 'Bob', 'David', 'Ellena']
names.append('Candy')
print(names) # ==> ['Alice', 'Bob', 'David', 'Ellena', 'Candy']

insert

insert()方法需要两个参数，分别是需要插入的位置，以及需要插入的元素。

复制代码

names = ['Alice', 'Bob', 'David', 'Ellena']
names.insert(2, 'Candy')
print(names) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

删除（pop）

pop

pop()方法默认删除列表的最后一个元素，并返回。

复制代码

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop()
print(name) # ==> Ellena
print(L) # ==> L = ['Alice', 'Bob', 'Candy', 'David']

pop()还可以接收一个参数，指定需要删除的元素的位置。

复制代码

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop(2)
print(name) # ==> Candy
print(L) # ==> ['Alice', 'Bob', 'David', 'Ellena']

替换

可以通过索引指定位置，并赋值新的元素，即可替换列表中原有的元素

复制代码

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
L[2] = 'Canlina'
print(L) #['Alice', 'Bob', 'Canlina', 'David', 'Ellena']

元组Tuple

定义元组的方式是使用小括号()将元组内的元素括起来，通过下标的方式访问元素。
使用tuple(列表名)列表转换成元组，同样，使用list(元组名)元组转换成列表。
tuple和list不一样的是，tuple是固定不变的，tuple中的每一个元素都不可被改变，同时也不能再往tuple中添加数据，而list是可以的。
性能比list好

count()方法

count()方法用来统计tuple中某个元素出现的次数。

复制代码

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1

对于不存在的元素，count方法不会报错，而是返回0，这是合理的，因为元组里面有0个不存在的元素。

复制代码

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(10)) # ==> 0

index()方法

index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

复制代码

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 # 多次出现，返回第一次出现的位置

注意，index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。

复制代码

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(100)
# 报错

元组中一些容易忽略的问题

空元组

空元组会直接打印()

复制代码

T = ()
print(T) # ==> ()

创建包含一个元素的tuple，会打印出一个字符串，这是因为括号可以作为计算运算符

复制代码

T = (1)
print(T) # ==> 1

复制代码

result = 3 * (4 - 2)
print(result) # ==> 6

想要改变此状况，在括号后面加一个,逗号即可，但是在多个元组里面加是没有效果的

复制代码

T = (1, )
print(T) # ==> (1, )

复制代码

>>> T = (1, 2, 3,)
>>> print(T) # ==> (1, 2, 3)

元组里面的列表可以被修改

复制代码

T = (1, 'CH', [3, 4])
L = T[2]
L[1] = 'ssssss'
print(T) # (1, 'CH', [3, 'ssssss'])

容器Dict

就是对象，它的key必须用''引号包裹着，dict中的元素是无序的，也就是dict中元素的插入顺序和打印顺序未必一致。

特点：查找速度快，查询10个或10万个速度都是一样的，而list的查找速度随着元素增加而逐渐下降。
缺点：就是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

获取

d.keys()就是获取key
d.values()获取dict所有的value
d.get('Alice')通过key获取值
d.clear()清除所有元素

遍历获取

使用for in进行遍历
通过dict提供的items()方法，items()方法会返回dict中所有的元素，每个元素包含key和value。```
d = {'Alice': [50, 61, 66], 'Bob': [80, 61, 66], 'Candy': [88, 75, 90]}
for key, value in d.items():
for score in value:
print(key, score)

复制代码

结果：
('Bob', 80)
('Bob', 61)
('Bob', 66)
('Alice', 50)
('Alice', 61)
('Alice', 66)
('Candy', 88)
('Candy', 75)
('Candy', 90)

复制代码

### <a class="reference-link" name="新增append(x)"></a><span class="header-link octicon octicon-link"></span>新增append(x)

d = {
'Alice': 45,
}
d['Candy'].append(88)

复制代码

### <a class="reference-link" name="删除pop(x)"></a><span class="header-link octicon octicon-link"></span>删除pop(x)

pop()方法的参数是dict中的key，当key不存在时，同样会引起错误

d = {
'Alice': 45
}
name = 'Ali2ce'
if name in d.keys():
d.pop(name)
else:
print('{} not in d'.format(name))

复制代码

<a class="reference-link" name="集合Set"></a><span class="header-link octicon octicon-link"></span>集合Set
------------------------------------------------------------------------------------------------------

[学习链接](https://github.com/jackfrued/Python-Core-50-Courses/blob/master/%E7%AC%AC11%E8%AF%BE%EF%BC%9A%E5%B8%B8%E7%94%A8%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B9%8B%E9%9B%86%E5%90%88.md)

### <a class="reference-link" name="为啥要有set，这玩意具体是干嘛用的"></a><span class="header-link octicon octicon-link"></span>为啥要有set，这玩意具体是干嘛用的

1. 有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是**保证这个集合的元素不会重复**，这时，set就派上用场了。
2. set和list类似，拥有一系列元素，但是set和list不一样，set里面的元素是不允许重复的，而list里面可以包含相同的元素；set与list的另一个区别是，set里面的元素是没有顺序的。

### <a class="reference-link" name="set和list的区别"></a><span class="header-link octicon octicon-link"></span>set和list的区别

1. set和list不一样，set里面的元素是不允许重复的，而list里面可以包含相同的元素；
2. set与list的另一个区别是，set里面的元素是没有顺序的，因此我们不能像list那样通过索引来访问。用`in`来判断某个元素是否在set中。

s = set([1, 4, 3, 2, 5, 4, 2, 3, 1])
print(s) # ==> set([1, 2, 3, 4, 5]) 重新排序了且去重了
print(1 in s) # ===> True

复制代码

### <a class="reference-link" name="读取 x in X"></a><span class="header-link octicon octicon-link"></span>读取 x in X

必须大小写完全匹配

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)

请问'Alice'是班里面的同学吗？

print('Alice' in name_set ) # ==> True

复制代码

### <a class="reference-link" name="添加（单个add、多个update）"></a><span class="header-link octicon octicon-link"></span>添加（单个add、多个update）

1. 以使用add()方法，往set里面添加元素。如果添加一个已经存在的元素，不会报错，也不会改变什么。```
  names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
  name_set = set(names)
  name_set.add('Gina')print(name_set) # ==> set(['Gina', 'Alice', 'Candy', 'David', 'Ellena', 'Bob'])

update()方法，可以一次性给set添加多个元素。结果是无序的```
names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
new_names = ['Hally', 'Isen', 'Jenny', 'Karl'] #新成员
name_set = set(names)
name_set.update(new_names)
print(name_set) # ==> set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])

复制代码

### <a class="reference-link" name="删除remove(x)"></a><span class="header-link octicon octicon-link"></span>删除remove(x)

如果remove的元素不在set里面的话，那么将会引发错误。所以，删除前要判断元素是否在set里面

#如果set中包含这个元素，就将其删除，否则添加到set里面去。
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
S = set([1, 3, 5, 7, 9, 11])
for item in L:
if item in S:
S.remove(item)
else:
S.add(item)
print(S)

复制代码

### <a class="reference-link" name="操作set的其他方法"></a><span class="header-link octicon octicon-link"></span>操作set的其他方法

#### <a class="reference-link" name="不会报错的删除方法discard(x)"></a><span class="header-link octicon octicon-link"></span>不会报错的删除方法discard(x)

和remove()不同的是，当元素不存在时，使用discard()并不会引发错误，所以使用discard()是更加高效的一个方法。

#### <a class="reference-link" name="清除所有元素的方法clear()"></a><span class="header-link octicon octicon-link"></span>清除所有元素的方法clear()

可以快速清除set中的所有元素。

#### <a class="reference-link" name="集合的子集和超集issubset(x)"></a><span class="header-link octicon octicon-link"></span>集合的子集和超集issubset(x)

通俗来讲就是父子级关系判断，判断其中一个set是否为另外一个set的子集或者超集。

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])

判断s1是否为s2的子集

s1.issubset(s2) # ==> True

判断s2是否为s1的超集

s2.issuperset(s1) # ==> True

复制代码

#### <a class="reference-link" name="判断集合是否重合isdisjoint(x)"></a><span class="header-link octicon octicon-link"></span>判断集合是否重合isdisjoint(x)

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
s1.isdisjoint(s2) # ==> False，因为有重复元素1、2、3、4、5

复制代码

已知两个集合s1、s2，请判断两个集合是否有重合，如果有，请把重合的元素打印出来。

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
flag = s1.isdisjoint(s2)
if not flag:
for item in s1:
if item not in s2:
continue
print(item) # 1 2 3 4 5

复制代码

<a class="reference-link" name="函数"></a><span class="header-link octicon octicon-link"></span>函数
------------------------------------------------------------------------------------------------

### <a class="reference-link" name="对函数入参进行类型的校验isinstance(x,[int/str/list/tuple])"></a><span class="header-link octicon octicon-link"></span>对函数入参进行类型的校验isinstance(x,\[int/str/list/tuple\])

isinstance(100, int) # ==> True

复制代码

实现函数func，当参数类型为list时，返回list中所有数字类型元素的和，当参数类型为tuple时，返回tuple中所有数字类型元素的乘积。

def func(param):
if isinstance(param, list):
result = 0
for item in param:
if isinstance(item, int) or isinstance(item, float):
result += item
return result
elif isinstance(param, tuple):
result = 1
for item in param:
if isinstance(item, int) or isinstance(item, float):
result *= item
return result
return None

print(func((1,3,54,'62')))#162
print(func([1,3,54,'62']))#58

复制代码

### <a class="reference-link" name="使用可变参数args和可变关键字参数kwargs"></a><span class="header-link octicon octicon-link"></span>使用可变参数args和可变关键字参数kwargs

> 使用可变参数*args和可变关键字参数\**kwargs

`*args`包裹未知参数，`**kwargs`包裹未知关键字参数，表示传入值或长度不确定，有无穷多个

def a(n, age=18, *args, **kwargs):
if age >= 18:
for item in args:
print(i)
else:
print('no!')
print(kwargs['ns'])
print(kwargs['nt'])

a(1,12,2,3,4,6,9,ns=15,nt=18)

复制代码

编写一个函数，它接受关键字参数names，gender，age三个list，分别包含同学的名字、性别和年龄，请分别把每个同学的名字、性别和年龄打印出来。

def info(**kwargs):
names = kwargs['names']
gender_list = kwargs['gender']
age_list = kwargs['age']
index = 0
for name in names:
gender = gender_list[index]
age = age_list[index]
print('name: {}, gender: {}, age: {}'.format(name, gender, age))
index += 1

info(names = ['Alice', 'Bob', 'Candy'], gender = ['girl', 'boy', 'girl'], age = [16, 17, 15])

复制代码

### <a class="reference-link" name="Lambda"></a><span class="header-link octicon octicon-link"></span>Lambda

如果我们要定义的函数非常简单，只有一行代码且不需要函数名，可以使用`Lambda`函数（匿名函数）。

import operator, functools

一行代码定义求阶乘的函数

fac = lambda num: functools.reduce(operator.mul, range(1, num + 1), 1)

一行代码定义判断素数的函数

is_prime = lambda x: x > 1 and all(map(lambda f: x % f, range(2, int(x ** 0.5) + 1)))

调用Lambda函数

print(fac(10)) # 3628800
print(is_prime(9)) # False

复制代码

### <a class="reference-link" name="常用的函数"></a><span class="header-link octicon octicon-link"></span>常用的函数

请定义一个`square_of_sum()`函数，它接收一个list，返回list中每个元素平方的和。

Enter a code

def square_of_sum(list):
sum = 0
for x in list:
sum = sum + x * x
return sum
print(square_of_sum([1,2,3,4,5])) #55

复制代码

倒计时

import time
def time_main(func):
def call_func():
print("开始运行程序...")
start = time.time()
func()
stop = time.time()
print("结束程序")
print(f"共耗费了{(stop-start):.2f}秒")
return call_func

def myfunc():
time.sleep(2)
print("I love You")

myfunc = time_main(myfunc)
myfunc()

复制代码

<a class="reference-link" name="对比js类型"></a><span class="header-link octicon octicon-link"></span>对比js类型
--------------------------------------------------------------------------------------------------------

我们在JSON中使用的数据类型（JavaScript数据类型）和Python中的数据类型也是很容易找到对应关系的，大家可以看看下面的两张表。

表1：JavaScript数据类型（值）对应的Python数据类型（值）

 <table><thead><tr><th>JSON</th> <th>Python</th> </tr></thead><tbody><tr><td>`object`</td> <td>`dict`</td> </tr><tr><td>`array`</td> <td>`list`</td> </tr><tr><td>`string`</td> <td>`str`</td> </tr><tr><td>`number`</td> <td>`int` / `float`</td> </tr><tr><td>`number` (real)</td> <td>`float`</td> </tr><tr><td>`boolean` (`true` / `false`)</td> <td>`bool` (`True` / `False`)</td> </tr><tr><td>`null`</td> <td>`None`</td></tr></tbody></table>

表2：Python数据类型（值）对应的JavaScript数据类型（值）

 <table><thead><tr><th>Python</th> <th>JSON</th> </tr></thead><tbody><tr><td>`dict`</td> <td>`object`</td> </tr><tr><td>`list` / `tuple`</td> <td>`array`</td> </tr><tr><td>`str`</td> <td>`string`</td> </tr><tr><td>`int` / `float`</td> <td>`number`</td> </tr><tr><td>`bool` （`True` / `False`）</td> <td>`boolean` (`true` / `false`)</td> </tr><tr><td>`None`</td> <td>`null`</td></tr></tbody></table>

<a class="reference-link" name="注意事项"></a><span class="header-link octicon octicon-link"></span>注意事项
----------------------------------------------------------------------------------------------------

### <a class="reference-link" name="元组(tuple)的内容不能修改"></a><span class="header-link octicon octicon-link"></span>元组(tuple)的内容不能修改

tup = (1, 2, 3, 4, 5, 6)
tup[0] = 11 # 修改元组元素的操作是非法的

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not #support item assignment

复制代码

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

复制代码

string、list 和 tuple 都属于 sequence（序列）。

注意：  
1、与字符串一样，元组的元素不能修改。  
2、元组也可以被索引和切片，方法一样。  
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。  
4、元组也可以使用+操作符进行拼接。

<a class="reference-link" name="类"></a><span class="header-link octicon octicon-link"></span>类
----------------------------------------------------------------------------------------------

class C:
def ss(self): # self必加
print(21312)

css = C()
css.ss()

复制代码

传参数和继承类

class Animal:
def init(self,name,age):
self.name = name
self.age = age
def say(self):
print(f"大家好，我叫{self.name}，今年{self.age}岁");
class Pig(Animal):
def special(self):
print("我会攻打大白菜");

p = Pig('小白',6);
p.say(); # 大家好，我叫小白，今年6岁
p.special(); # 我会攻打大白菜

复制代码

<a class="reference-link" name="pyGame"></a><span class="header-link octicon octicon-link"></span>pyGame
--------------------------------------------------------------------------------------------------------

运行示例游戏：

#验证pygame模块是否成功命令
python -m pygame.examples.aliens

复制代码

<a class="reference-link" name="用FastAPI开发网络数据接口"></a><span class="header-link octicon octicon-link"></span>用FastAPI开发网络数据接口
----------------------------------------------------------------------------------------------------------------------------

FastAPI 是一个用于构建API（网络数据接口）的现代、高性能的Web框架，基于Python 3.6+，使用了Python中的类型提示进行类型检查，非常符合工程化开发的需求，在业界有非常好的口碑。下面，我们先用代码告诉大家FastAPI到底能做什么，然后再来讲解它的方方面面。

### <a class="reference-link" name="FastAPI五分钟上手"></a><span class="header-link octicon octicon-link"></span>FastAPI五分钟上手

1. 安装依赖库和ASGI服务器（支持异步I/O的Python服务器）。

pip install fastapi
pip install uvicorn

复制代码

2. 编写代码`main.py`。

from fastapi import FastAPI

app = FastAPI()

@app.get('/getAricle')
def say_hello(id = ""):
return {'code': 200, 'message': f'id：{id}，hel21312321lo, world!'}

复制代码

3. 运行服务。

uvicorn main:app --reload

复制代码

> **说明**：上面运行uvicorn时使用的`--reload`参数会在代码发生变更时自动重新加载新的内容，这个参数在开发阶段非常的有用。
4. 访问服务。

![](res/run-first-demo.png)<http://127.0.0.1:8000/getAricle?id=1>
5. 查看文档。

> **注意**：FastAPI会基于[Swagger UI](https://swagger.io/tools/swagger-ui/)自动为数据接口生成对应的文档。

[http://127.0.0.1:8000/docs#/default/say\_hello\_getAricle\_get](http://127.0.0.1:8000/docs#/default/say_hello_getAricle_get)

<a class="reference-link" name="注意事项"></a><span class="header-link octicon octicon-link"></span>注意事项
----------------------------------------------------------------------------------------------------

我曾踩过的坑，`pip list`可以列表py包，但是应用时打死都无法运行，解决：确保你的`python`版本只有一个，去你的安装路径查看，一般在C盘：

C:\Users\Administrator\AppData\Local\Programs\Python\Python311

复制代码

上一篇 / python发送邮件带多个附件代码下一篇 / 一千万的sql数据，你是怎么查询的？

初学者的Python基本语法笔记

一些python算法

字符串

替换文案format

拼接字符串/清除前后空格

常用方法

容器List

查看/排序

添加（append、insert）

append

insert

删除（pop）

pop

替换

元组Tuple

count()方法

index()方法

元组中一些容易忽略的问题

空元组

元组里面的列表可以被修改

容器Dict

获取

遍历获取

请问'Alice'是班里面的同学吗？

判断s1是否为s2的子集

判断s2是否为s1的超集

一行代码定义求阶乘的函数

一行代码定义判断素数的函数

调用Lambda函数

Enter a code

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not #support item assignment

🎯 相关文章

💡 推荐文章

🕵️‍♂️ 评论 (0)