Python笔记摘要

最新推荐文章于 2023-04-25 09:00:00 发布

AsiaFT.

最新推荐文章于 2023-04-25 09:00:00 发布

阅读量181

点赞数 1

文章标签： python

本文链接：https://blog.csdn.net/m0_46181452/article/details/116108048

版权

Python 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

弱类型语言(Java 是强类型语言)：声明变量时不需要指定类型
数值类型：整数(int)，浮点数（float 没有单精度、双精度之分），布尔值（bool True， False：首字母一定是大写），复数（complex）
查看变量数据类型： type
字符串(str)：单引号，双引号，三引号（三单引号，三双引号）
注释： ‘’’’’’
‘’’’’’
赋值内容中存在单双引号，怎么输出？：嵌套使用，里面要是双引号的话，外面就弄成单引号（单双引号嵌套）；三引号
双引号和三引号区别：
三引号可以作为多行注释；
三引号可以保留格式，单/双引号不可以

str=‘床前明月光，
疑似地上霜’

str=’’‘床前明月光，
疑似地上霜’’’

1）换行：
print(“春眠不觉晓，”)
print(“处处闻啼鸟。”)

2）不换行：
print(“春眠不觉晓，”,end="")
print(“处处闻啼鸟。”,end="")

特殊字符\n
整个字符串前面加上一个r 或者R : ‘pytho\n’-> ‘pytho\n’-> r’pytho\n’-> R’pytho\n’
print (’\\\’)：转义
运算符：算术运算符(+ - * / % // -> 整除， ** -》幂运算)、赋值运算符、比较运算符（==）
10/3 =3.333 (python2 只取3， python3 会取小数)
10//3=3
10**3= 1000

print(“hello”,“world”) hello world
print (“hello”+“world”) helloworld

print (1+ “hello”)??

同一种类型可以相加：
print（11+ True） # 11 ： True： 1， False ： 0
因为布尔值和数字都是数值类型
乘法：1）相同类型才可以进行相乘运算； 2）可以进行字符串的多次输出
print("hello "*3)??
list1=[1,2,3]
list2=[2,3,4]
list1 + list2
list1 * 2
比较运算符： > < !=（<> python 3 不支持） == >= <=, 结果只有True或False
赋值运算符： == += -= *= /= %= **= //=, python 不支持a++ 或者 a–的赋值方式
逻辑运算符： and or not 返回结果是True 或者False
成员运算符： in 和 not in：判断指定内容是否在变量中，返回True或Flase
str = “hello”;
print(“he” in str) # True
数值类型不能拆分，是不能用in 和 not in
str=True
print(“T” in str)

算术》比较》逻辑（not》 and 》 or）

类型转换：变量上包裹上想要转换成的对应的类型即可
1）非0值或非空值转为bool时，都是True ： data=10; bool(data) #True
2） 0 和空值转为bool时，值为False: data=""; bool(data) # False

str->int/float/bool

非空字符串，转成bool时，值为True
2）空字符串，转为bool时，值为False
3）str转为int/float 是要求本身内容是数值型才可以

7.变量赋值方式：变量是一个容器（内存：使用id() 查看变量的内存地址），用来存储数据
1）单个变量赋值： id(age1) 相同值: id获取内存地址，多个变量会使用同一个内存地址，范围:[-5,256]

2）连续赋值，不同变量有相同的值：age1=age2=age3=18，可以使用同一个内存空间（如果初始值一样，建议使用连续赋值方式）
3）连续赋值，不同变量有不一样的值：name,sex,age=‘Asia’,‘girl’,‘18’
【注】：变量的个数要和声明的个数保持一致
回收机制：变量个数少于值的个数，且不报错，该如何处理？
使用回收机制。变量前面加个*
1) *a,b,c=1,2,3,4,5,6,7
* 可以接收其他变量接收不了的值, 通常在函数里用到，未知函数个数时，可用
print(a) #[1,2,3,4,5]
print(b) #6
print© #7

								2) a,*b,c=1,2,3,4,5,6,7
								print(a) #1
								print(b) #[2,3,4,5,6]
								print(c) #7

一、字符串

字符串的取值：只能拿到一个字符
1）正序: 第一位是0
2）反序：最后一位是-1
如：str=“hello”
print(str[0])
print(str[-5])
输出某个子串，hello中：如he，hlo：
切片：连续；取头不取尾，只能取到end-1
字符串名[start🔚step]
start: 开始索引
end：结束索引+1
step：步长
正序：print(str[0:2:1]) # he
反序：print(str[-5:-3:1]) # he, start肯定小于end，不要写成，print(str[-3:-5:1])
不连续：通过step控制

常用的切片方法
1）str[start:end] : 从start取到end-1，当步长为1时，可以省略步长的书写
print(str[0:5]) # hello
2) str[:] : 将三个参数均省略，可以取到整个字符串.但是中间的: 不可以省略
print(str[:])
3）str[start:] # 从指定位置开始取到结尾
4）str[:end] #从头取到end-1长的字符
5）倒序输出: str[::-1]

二、字符串常用方法：’’, " “, “”” “”"
1）以xxx开头：字符串.startswith(“判断字符串”)，返回True或Flase。注意是starts，因为字符数不止一位
在学习单元测试时，执行结果的判断，是否以fail开头。注意是ends，因为字符数不止一位
2）以xxx结尾：字符串.endswith(“判断字符串”)，返回True或False
如判断是否是农村户口或者城市户口。身份证上地址栏里，判断是否含村。或者判断文件类型是否是某种类型
3）判断字符串是否是纯数字,是的话，才可以进行字符转换: 字符串.isdigit()
4）去除两端指定字符：字符串.strip(“指定字符”)，返回一个字符串。注意必须要是首尾才行。不会改变原来的字符串
应用场景：获取用户输入的时候，记得使用
如： str="@@@111@11***"
print(str.strip("@"))
可以嵌套使用：去掉首尾@和*
print(str.strip("@").strip("*"))
如果想要去除中间的@，则需要“切片”

str3="@@@hello @ python***"
print(str3.strip("@"))
hello @ python***

print(str3.strip("@").strip("")) #去除掉首尾的@ 和
hello @ python

print(str3.strip("@").strip("")[:6],str3.strip("@").strip("")[8:]) # 去除中间的@，只能用切片
hello python

print(str3.strip("@").strip("")[:6]+str3.strip("@").strip("")[8:]) # 用逗号会多一个空格，用+ 会不多空格
hello python

print(str3[3:8]+str3[10:17]) # 或者直接切片，不截取函数strip
hello python

如： str4="   @@@hello Python ****    "
print(str4.strip("@")) # 此时去不掉开头的@，因为str4 开头的元素并非@，而是空格

str4=" @@@@Hello"
print(str4.strip("@"))
@@@@Hello
5）字符串字符大写：字符串.upper()，会生成一个新的字符串，不会影响原来的字符串
字符串字符小写：字符串.lower()
应用场景：验证码的判断
6）字符串替换，结果得到一个新的字符串，不指定次数，全部替换
字符串名.replace(“存在的字符串”,“替换的新字符串”,“替换的次数”)
7）切割：用户名|密码|年龄，元素存到列表中。不指定次数，全部切割
字符串.split(“分割符号”,“指定切割次数”)
应用场景：切割获取账号名、密码等

str5=“zyx|hello|23”
print(str5.split("|"))
[‘zyx’, ‘hello’, ‘23’]

三、列表的操作: []

查看类型，type()
查看长度:len()
列表的元素：python中支持的所有数据类型都可以，可以混杂着放

lst=[“zyx”,27,110,[98,99,96],“优秀”]
print(lst)
[‘zyx’, 27, 110, [98, 99, 96], ‘优秀’]

列表元素可变，有序
列表操作：增删改查
·查(和字符串操作一致)：
1）单个元素：列表名[索引值] （可以正序、反序）
2）多个元素：切片, 列表名[start🔚step], 同样取头不取尾

lst=[“zyx”,27,110,[98,99,96],“优秀”]
print(lst)
[‘zyx’, 27, 110, [98, 99, 96], ‘优秀’]

print(lst[3])
[98, 99, 96]

print(lst[0])
zyx

print(type(lst[0]),type(lst[3]))
<class ‘str’> <class ‘list’>

print(lst[0:4:3]) # 使用切片，获取名称和成绩，步长为3，是为了不让其再取到下一个元素
[‘zyx’, [98, 99, 96]]

print(type(lst[0:4:3]))
<class ‘list’>
3）倒序输出：

print((lst[::-1]))
[‘优秀’, [98, 99, 96], 110, 27, ‘zyx’]
·增加：
1）附加：列表名.append(元素值): 在后面增加，每次只能增加一个元素。修改原列表
2）指定位置：列表名.insert(索引值,元素值)
3）列表的扩展:
#两个列表相加，生成新列表：

lst1=[1,2,3,4]
print(lst+lst1)
[‘zyx’, 27, 110, [98, 99, 96], ‘优秀’, 1, 2, 3, 4]
#列表A.extend(列表B)：在列表A 后新增列表B，列表A已变化。extend本身返回none，但是原列表已改变

print(lst)
[‘zyx’, 27, 110, [98, 99, 96], ‘优秀’]

print(lst.extend(lst1)) # 返回none是因为extend源码，本身的数据类型就是none
None

print(lst.extend([1,2,3,]))
None

print(lst.extend([1,2,3]))
None

print(lst.extend([‘1’,‘2’,‘3’]))
None

print(lst)
[‘zyx’, 27, 110, [98, 99, 96], ‘优秀’, 1, 2, 3, 4, 1, 2, 3, 1, 2, 3, ‘1’, ‘2’, ‘3’]

lst3=[“Happy”,“Sad”]
lst.extend(lst3) #extend 可以在括号里输入列表名
print(lst)
[‘zyx’, 27, 110, [98, 99, 96], ‘优秀’, 1, 2, 3, 4, 1, 2, 3, 1, 2, 3, ‘1’, ‘2’, ‘3’, ‘Happy’, ‘Sad’]

print(type(lst.extend(lst3)))
<class ‘NoneType’>
4）列表删除：

列表名.remove(元素值)：从左到右找到第一个删除，改变原列表

列表名.pop(索引值)：带索引值，则删除索引所指元素；不带索引值，则删除最后一个。

列表名.clear(): 清空元素列表

del 列表名[索引值], 可以删除多个值，使用切片。

lst=[“zyx”,18,160,[98,91]]
print(lst[-3👎1]) #倒序取列表元素： start=-3 (18), end=-1([98,91]), 依据取头不取尾，取18,160
[18, 160]

del (lst[-3👎1])
print(lst)
[‘zyx’, [98, 91]]
5）元素值更改：
#单个元素值修改
lst[0]=1
#多个元素值修改,前三个元素值变为1,2,3。使用切片
lst[:3]=[1,2,3] # 右边的值必须要是列表才行
6）倒序输出列表：对原列表进行倒序，没有生成新的列表
lst.reverse()
7）获得元素的索引值：
lst.index(元素值)：输出第一个对应该元素值的索引值
注:1=True, 0=False

lst1=[1,3.1,True]
print(lst1.index(True))
0 # 因为1===True，所以先输出1的索引
8）统计某一元素出现的次数:
lst.count(元素值)

lst1=[1,3.1,True]
print(lst1.index(True))
print(lst1.count(True)) # 1和True
2