python认知基础篇3

21.【python-pass】

pass：在python中，没有实际意思，专门用来保持语法的完整性。

if 条件:
    pass
else:
    pass


class A:
    pass

22.【python-字符串的格式化】

python中支持3种字符串的格式化：

【方式1】：基于百分号%方式，是python中最早支持的字符串格式化方式。（python任何版本都支持）
%s：给字符串占位
%d：给数字占位
或者支持起个名字n1：%(n1)s

例如：
name = "张三"
age = 18

text = "我叫%s,今年%s岁了" % (name, age)
print(text)
或者用起个名字方式：
text = "我叫%(n1)s,今年%(n5)s岁了" % {"n1":name, "n5":age}
print(text)

【方式2】：基于format方式（python任何版本都支持）
带序号的：
text = "我叫{0},今年{1}岁了".format(name, age)
不带序号的：
text = "我叫{},今年{}岁了".format(name, age)

说明：
1.这种带序号的，因为有序号，则可以复用序号的值。
text = "我叫{0}, 真实名字叫{0}, 今年{1}岁了".format(name, age)
2.开发过程中，为了方便，通常不使用序号的格式。

【方式3】：f-string方式.（python 3.6+版本才支持）
格式例如：f"我叫{name},今年{age}岁了" 

name = "张三"
age = 18

text = f"我叫{name},今年{age}岁了" 
print(text)

说明：
1.f-string方式中，{}代表的是代码块，里面也可以做代码运算
f"我叫{name + "abc"},今年{age + 5 }岁了" 

基于百分号%方式，格式化字符串

基于百分号%方式，格式化字符串

基于format方式，格式化字符串

f-string方式.（python 3.6+版本才支持）

23.【python-数据类型】

python中的数据类型，如：

str：字符串类型
int：整型
list：列表类型
...

24.【字符串类型-独有函数】

字符串类型：

1.字符串类型格式：一对单引号''、或一对双引号""、或一对三引号 """文本"""或'''文本'''均可。
v1 = 'abc'
v2 = "abcd"
v3 = """abcde"""
v4 = '''abcde'''

v3、v4如果没有此变量，则python会认为是注释。

2.变大写"Abc".upper()方法
result  = "Abc".upper()方法，把字符串变大写,生成新的值并作为结果返回。并不会影响到原字符串。

3.变小写"Abc".lower()方法
result  = "Abc".lower()方法，把字符串变小写，生成新的值并作为结果返回。并不会影响到原字符串。

4.result = "*".join(list_data)，用指定符号（"*"为例）把list元素拼接在一起
list_data = ['北京', '上海', '广州', '深圳']
result = "*".join(list_data)
print(result)
打印结果：
北京*上海*广州*深圳
说明：拼接url参数，可以使用：result = "&".join(xx)

5.result = "".isdecimal()判断字符串是不是整数
"123".isdecimal(),结果：True
"abc".isdecimal(),结果：False

6.result = startsWith("xx")/endsWith("xx")判断字符串以什么开头/结尾吗?
result = "China".startsWith("Ch")，结果result：True
result = "China".endsWith("ao")，结果result：False

7.result = "".replace(old, new) 替换字符串，生成新的值并作为结果返回。并不会影响到原字符串。
text = "Hello world!"
result = text.replace("H", "h")
print("result:", result)
print("text:", text)

8.data_list = "".split(",")用指定符号，切割字符串。从左侧开始找
切割过程中，还可以用maxsplit=，来指定切割多少个：
data_list = "".split(",", maxsplit=2)

例如：
text = "北京,上海,广州,深圳"
print(text.split(","))
print(text.split(",", maxsplit=2))

结果：
['北京', '上海', '广州', '深圳']
['北京', '上海', '广州,深圳']

9.data_list = "".rsplit(",")用指定符号，切割字符串。从右侧开始找
切割过程中，同样还可以用maxsplit=，来指定切割多少个：
data_list = "xxx".rsplit(",", maxsplit=2)

10.result = txt.strip()函数，去除txt两端的空白（空格、换行、制表符等）,中间的空白不管。
result = txt.lstrip()函数，这里的l即left的首字母，去除左端的空白（空格、换行、制表符等）,中间的空白不管。
result = txt.rstrip()函数，这里的r即right的首字母，去除右端的空白（空格、换行、制表符等）,中间的空白不管。
例如：
txt1 = " 你好，中国 "

print("原字符串,长度：", len(txt1))
print("txt1.strip()长度：", len(txt1.strip()))
print("txt1.lstrip(),长度：", len(txt1.lstrip()))
print("txt1.rstrip(),长度：", len(txt1.rstrip()))

结果：
原字符串,长度： 7
txt1.strip()长度： 5
txt1.lstrip(),长度： 6
txt1.rstrip(),长度： 6

11.result = txt.__contains__("xx")判断字符串中是否包含某个字符串
等价于：result = "xx" in txt，这种更常用。
例如：
txt = "你好，中国！"
result1 = txt.__contains__("中")
result2 = "中" in txt

print("result1:", result1)
print("result2:", result2)

结果：
result1: True
result2: True

12.txt.count("xx")计算txt字符串中含字符串“xx”的个数
例如：
txt = "abcdeabcd"
print(txt.count("ab"))
print(txt.count("cde"))
结果：
2
1

13.查找某个子字符串的索引，如果存在多个时，返回第一个位置处的索引：
txt.index("xx"),找不到就报错：ValueError: substring not found
txt.find("xx")，找不到，返回-1

14.让字符串txt，c位化。
语法：result = txt.center(长度, "#")
说明：
1.center(长度, "#")中，长度时总长度，不够时用指定符号（以#号为例）凑数
"#",凑数的符号。以#号为例。可以为其它，例如txt.center(长度, "*")
例如：
result = "你好,中国!".center(20, "*")
print(result)
print(len(result))
结果：
*******你好,中国!*******
20

15.python中的原始字符串：\n、\t
如果需要原始打印出来，前面加上r可以防止转义。
r"\n"
r"\t"

让字符串txt，c位化。

upper()方法和lower()方法

txt.isdecimal()判断字符串是不是整数

startsWith()/endsWith()判断字符串以什么开头/结尾吗?

txt.replace(old, new) 替换字符串，生成新的值并作为结果返回

split()用指定符号，切割字符串

join()函数

txt1.strip()去两端空白

判断字符串中是否包含某个字符串

25.【字符串类型-可用的公共函数】

公共函数，字符串中也可以调用的，其它数据类型中也可以调用的：
1.获取长度，len(xx)函数，

2.按所有取值，txt[index]
例如：txt = "abc"
print(txt[0])
结果：a

3.切片，切出的子串后作为新的字符串返回。
格式：txt[m,n],其中m：开始位置，n结束位置。顾头不顾尾
例如：
txt = "abcdefg"
print(txt[1:4])
结果：bcd

切片的同时，可以指定步长：txt[m,n:s],其中m：开始位置，n结束位置,s:步长。顾头不顾尾
例如：
txt = "1a2b3c4d5e6f7g8"
print(txt[1:15:2])
结果：abcdefg

切片，切出的子串后作为新的字符串返回。txt[m,n],顾头不顾尾

切片的同时，可以指定步长：txt[m,n:s]

26.【打开文件】

更详细文件操作可以，看见后面笔记：第45-文件操作，点击下方直达:

2023-python】41-50, 列表推导式、字典推导式、集合推导式、元组无推导式、文件操作、函数?

打开文件，方式1：

# 打开文件
f = open(r"路径", mode="r", encoding="utf-8")

# 操作文件(逐行读取文件)
for line in f:
    print(line)

# 关闭文件
f.close()

说明：
1.上面路径可以是决定路径，也可以是相对路径
2.mode="r"表示模式，r表示读取；w表示写入；a表示在上次文件内容之后拼接。
3.encoding="utf-8"表示以utf-8进行编码
-------------

打开文件，方式2：
with语法

27.【python-os】

import os

# 查看某路径下的所有文件os.listdir("路径")
name_list = os.listdir("C:\\Users\\15639\\Desktop")
print(name_list)

说明：
1.写路径的时候，为了防止\转义，可以这样：在路径前加上一个r，此时总能保证不出问题。
names_list = os.listdir(r"C:\Users\15639\Desktop")

28.【random-随机取样】

# 随机取样
list_data = random.sample(string.ascii_letters, 6)
print(list_data)

# 拼接在一起
random_str = "".join(list_data)
print(random_str)

29.【python-列表list】

列表是python中最常用的数据类型之一，也是最灵活的数据类型之一。

说明：
1.列表可以包含任何种类的数据类型：数字、字符串、元组、字典，也可以嵌套列表。
2.与字符串不同，列表是可变的。可变指的是我们在原处修改其中的内容，如删除、添加一个元素，
则列表中的其它元素自动缩短或者增长。也正是这种可变特点，其性能略低一点。
3.列表中的元素允许重复。

【1.创建列表】
用一对[ ]来表示列表，中间的元素之间用逗号分割开。
例如：
list1 = ["你好","中国","加油"]
list2 = [] #[]表示空列表
list3 = list(range(5))

【2.列表拼接合并】：result = list1 + list2
将2个或多个列表合并为1个列表，原有列表不变
例如：
l1 = ["a", "b", "c"]
l2 = [1, 2, 3]

l3 = l1 + l2
print(l3)
结果：
['a', 'b', 'c', 1, 2, 3]

【3.列表重复】：result = list1 * n
将列表中的元素重复n倍，并把复制后的合并后放在一个新的列表中。
例如：
l1 = ["a", "b", "c"]
l2 = l1 * 3
print(l2)
结果：
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

【4.列表成员判断】：in、not in,语法：
元素 in list_data
元素 not in list_data

例如：
l1 = ["a", "b", "c"]

print("a" in l1)
print("d" in l1)
print("a" not in l1)
结果：
True
False
False

【5.列表通过索引取值】索引从0开始。注意索引不要越界。
l1 = ["a", "b", "c"]
print(l1[1])
结果：b

【6.列表切片】切片，切出的list后作为新的list返回。
格式：list1[m,n],其中m：开始位置，n结束位置。顾头不顾尾
特别地：l1[0:-1]，-1表示结尾元素的索引。因顾头不顾尾，故最后一个元素取不到。

例如：
l1 = ["a", "b", "c", "d", "e"]
print(l1[1:4])
结果：['b', 'c', 'd']

7.【从头切到尾】因为顾头不顾尾，要想从头切到尾，可以这样4种方式：
l1 = ["a", "b", "c", "d", "e"]
print(l1[0:len(l1)])
print(l1[0::1])
print(l1[0::])
print(l1[0:])
结果为：
['a', 'b', 'c', 'd', 'e']
['a', 'b', 'c', 'd', 'e']
['a', 'b', 'c', 'd', 'e']
['a', 'b', 'c', 'd', 'e']

切片的同时，可以指定步长：list[m,n:s],其中m：开始位置，n结束位置,s:步长。顾头不顾尾
例如：
l1 = ["a", "b", "c", "d", "e"]
print(l1[0:-1:2])
结果：['a', 'c']

【8.反转列表】result = list1[::-1]
例如：
l1 = ["a", "b", "c", "d", "e"]
print(l1[::-1])
结果：['e', 'd', 'c', 'b', 'a']

【反转的同时，设置步长】result = list1[::-2]
l1 = ["a", "b", "c", "d", "e"]
print(l1[::-2])
结果：['e', 'c', 'a']

【9.遍历列表】
for item in list1:
    pass

-------

倒着遍历，索引正序：
l1 = ["a", "b", "c", "d", "e"]
for index in range(0, len(l1)):
    print(index, ":", l1[index])
结果：
0 : a
1 : b
2 : c
3 : d
4 : e

-------

倒着遍历，索引也倒序：
l1 = ["a", "b", "c", "d", "e"]
for index in range(len(l1)-1, 0-1, -1):
    print(index, ":", l1[index])
结果：
4 : e
3 : d
2 : c
1 : b
0 : a

说明：range(len(l1)-1, 0-1, -1):
a.0-1，即-1的由来：range因为顾头不顾尾，所以最开始的索引0要减去1，即：0-1
b.最后的-1的由来：控制方向，默认向右。-1表示向左方向。

【10.列表元素更新】修改指定位置的元素
l1 = ["a", "b", "c", "d", "e"]
l1[0] = 1
print(l1)
结果：
[1, 'b', 'c', 'd', 'e']

【11.列表删除元素】
语法：del 元素1,元素2...
或者直接删掉整个列表：del list1
说明：
1.直接删掉整个列表：del list1后，内存中就没有list1这个变量了。再使用就报错了。
NameError: name 'l1' is not defined

l1 = ["a", "b", "c", "d", "e"]
del l1[0],l1[2]
print(l1)
结果：
['b', 'c', 'e']

【12.清空列表】
list1 = ["a", "b", "c", "d", "e"]
print(list1)

list1 = []
print(list1)

结果：
['a', 'b', 'c', 'd', 'e']
[]

直接删掉整个列表：del list1后，内存中就没有list1这个变量了。再使用就报错了。

12.清空列表

倒着遍历，索引正序

倒着遍历，索引也倒序

【倒序】result = list1[::-1]

带步长的切片

从头切到尾的方式

30.【python-列表的常用方法】

【1】result = list1.index(element)获取元素的索引，默认从左向右找，找到一个后后面就不管了。
也可以指定区间查找，list1.index(element, start, end)
list_data = [1, 2, 3, "a", "b", "c", "aa", "bb", "cc"]
print(list_data.index("a"))
结果：3

【2】result = list1.count(element)计算列表中有指定元素element的个数
list_data = [1, 2, 3, "a", "b", "c", "aa", "bb", "cc"]
print(list_data.count("a"))
结果：1

【3】list1.append(element)在列表最后添加一个元素。一次只能添加1个元素
list_data = [1, 2, 3]
list_data.append("a")
print(list_data)
结果：[1, 2, 3, 'a']

【4】result = list1.pop(),默认删除列表最后一个元素，并把删除的元素作为结果返回。
result = list1.pop(index)，还可以删除指定索引来删除元素，同样把删除的元素作为结果返回。
list_data = [1, 2, 3]
list_data.pop()
print(list_data)

list_data.pop(1)
print(list_data)

结果：
[1, 2]
[1]

【5】list1.remove(element)从左到右去匹配，找到此元素并删除元素。此方法没有返回值。

【6】list1.extend(element),把元素追加到list1列表中。
若此元素本身已为列表，则会出现嵌套列表。
list1 = [1, 2, 3]
list2 = ["a", "b", "c"]
list1.append(list2)
print(list1)

结果：[1, 2, 3, ['a', 'b', 'c']]

【7】list1.clear()清空列表。说明：清空列表还可以直接赋值[],例如：
list1 = [1, 2, 3]
list1.clear()
print(list1)
结果：[]
---------------
list1 = [1, 2, 3]
list1 = []
print(list1)
结果：[]

【8】list1.insert(index,element),在指定位置处插入指定元素
list_data = [1, 2, 3]
list_data.insert(1, "a")
print(list_data)
结果：[1, 'a', 2, 3]

【9】list1.sort()排序，默认是升序排序。
若需要降序，则：list1.sort(reverse=True)

说明：
1.list1.sort()排序，没有返回值。是操作的原列表。如果多处都在用原列表，则排序会影响别处使用。
此方法是列表特有方法。

2.python内置函数result = sorted(list)将排序结果以新列表返回，不会动原列表。
此方法是公共方法，字符串也可以使用。

import random
list_data = list(range(10))
print("乱序前：", list_data)

random.shuffle(list_data)
print("乱序后：", list_data)

list_data.sort()
print("sort升序序后：", list_data)

list_data.sort(reverse=True)
print("sort降序后：", list_data)

结果：
乱序前： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
乱序后： [7, 5, 8, 1, 2, 3, 0, 6, 4, 9]
sort排序后： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sort降序后： [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

------------

python内置函数result = sorted(list)，举例：

import random
list_data = list(range(10))
print("乱序前：", list_data)

random.shuffle(list_data)
print("乱序后：", list_data)


result = sorted(list_data)

print("list_data:", list_data)
print("result:", result)

结果：
乱序前： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
乱序后： [7, 6, 5, 4, 9, 0, 8, 3, 2, 1]
list_data: [7, 6, 5, 4, 9, 0, 8, 3, 2, 1]
result: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

---------
sorted()排序字符串：

txt = "hello world 425"
result = sorted(txt)
print("".join(result))

结果：(前面有2个空格，我以下划线示意出来了，)
__245dehllloorw

list1.sort()排序，默认是升序排序。

list1.clear()清空列表，

list1.insert(index,element),在指定位置处插入指定元素