Python 学习笔记一

Source
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Katherine_hsr/article/details/82696885

字符串 str

作用:用来记录文本(文字)信息
字符串的表示方法:在非注释中,凡是用引号(’, “, ‘’’, “””)括起来的部分都是字符串。
空字符串的字面值表示方式:

' '
" "
' ' ' ' ' '
" " " " " "

非空字符串的字面值表示方式:

'hello'
"hello"
'''hello'''
"""hello"""

单引号和双引号的区别:
单引号内的双引号不算结束符;双引号内的单引号不算结束符。
三引号字符串:
作用:三引号字符串的换行会自动转换为换行符’\n’,三引号内可以包含单引号和双引号。

print('''I like cat
I like food
I like coffee''')

在这里插入图片描述
单引号,双引号,单三引号,双三引号几乎可以表示全部的内容。但是如果一个需要打印的内容里面同时含有单引号,双引号,单三引号,双三引号时便不适用。所以遇到这种情况需要使用转义序列代表特殊字符串。

用转义序列代表特殊字符

字符串字面值中,用字符反斜杠()后跟一些字符代表一个字符。
字符串中的转义字符表

\' 代表一个单引号
\'' 一个双引号
\\ 代表一个反斜杠
\n 换行
\r 返回光标至行首
\f 换页
\t 水平制表符
\v 垂直制表符
\b 倒退
\0 空字符,字符值为0
\0oo  oo为两位八进制表示的字符
\xXX XX为两位十六进制表示的字符
\uXXXX Unicode16的十六进制表示的字符
\uXXXXXXXX Unicode32的十六进制表示的字符

在这里插入图片描述

ASCII 编码

ASCII 字符表
我们可以看到输出的数据都是以ascii码形式进行存储的,输入如下指令可以查看到ascii对照表。

man ascii

在这里插入图片描述
在这里插入图片描述
常用ASCII编码:
字符 十进制 十六进制
‘0’ 48 0x30
‘A’ 65 0x41
‘a’ 97 0x61

raw 字符串(原始字符串)

字面值格式:

r'字符串内容'
r"字符串内容"
r'''字符串内容'''
r"""字符串内容"""

作用:让转义字符\无效
示例:

a = 'C:\newfile\test.py'
print(a)
print(len(a)) # 得到字符串的长度

a = r'C:\newfile\test.py'
print(a)
print(len(a))

在这里插入图片描述

字符串的运算

算术运算符:

# + 加号运算符用于字符串的拼接
x = 'abcd' + 'efg'
print(x)  # abcdefg

x += '123'
print(x)  # abcdefg123
* 运算符用于生成重复的字符串
x = '123'
y = x * 2  # y = '123123'

x *= 3 # x = 123123123

字符串的比较运算

运算符:

>; >=; <; <=; ==

示例:

'A' < 'B'  			# True
'B' < 'a'			# True
'ABC' > 'AB' 	# True
'AD' < 'ABC'	# False 首先比较A和A,然后比较D和B,D>B所以返回False不再进行第三位比较
'ABC' == 'abc'	# False

比较的时候是ascii编码做比较。
序列的比较以及元祖的比较规则与字符串的比较规则完全相同。

in 和 not in

作用:in 用于序列,字典,集合中,用于判断某个值是否存在于容器中,如果存在则返回True,否则返回False
格式:对象 in 容器
示例:

s = 'welcome to tarena'
'to' in s # True
'class' in s # False

'to' not in s # False
'class' not in s # True

字符串的索引操作

python 字符串str是不可以改变的字符序列
索引语法:字符串[整数表达式]
说明:python序列都可以用索引(index)来访问序列中的对象(元素)。
python序列的正向索引是从0开始的,第二个索引为1,最后一个索引为len(s)-1。python序列的反向索引是从-1开始的,-1代表最后一个,-2代表倒数第二个,第一个是-len(s)
在这里插入图片描述

切片 slice

作用:从字符串序列中去除一部分相应的元素重新组成一个字符串
语法:字符串[(开始索引b):(结束索引e)(:(步长s))] ()内括起来的部分代表可以省略。
说明:

  1. 开始索引是切片开始切下的位置0代表第一个元素,-1代表最后一个元素。
  2. 结束索引是切片的终止索引(但不包含终止索引)
  3. 步长是切片每次获取完当前索引后移动的方向和偏置量,没有步长,相当于取值完成后向后移动一个索引的位置(默认为1);当步长为正整数时,取正向切片,步长默认值为1,开始索引默认值为0,结束索引的默认值为len(s);当步长为负整数时,取反向切片,反向切片时,默认的起始位置为最后一个元素,默认的终止位置为第一个元素的前一个位置。
    示例:
s = 'ABCDE'
a = s[1:4]   # a = 'BCDE'
a = s[1:]    # a = 'BCDE'
a = s[:2]    # a = 'AB'
a = s[:]     # a = 'ABCDE'
a = s[4:2]   # a = ''
a = s[2:1000] # a = 'CDE' 开始索引和结束索引可以越界
a = s[1:4]   # a = 'BD'
a = s[::2]   # a = 'ACE'
a = s[1::2]  # a = 'BD'
a = s[::-1]  # a = 'EDCBA'
a = s[::-2]  # a = 'ECA'
a = s[4:0:-2] # a = 'EC'

常用的序列函数

len(seq)		# 返回序列的长度
max(x)			# 返回序列的最大值元素,根据ascii编码值的大小进行比较
min(x)			# 返回序列的最小值元素

字符串编码转换函数

ord(c)			# 返回一个字符串的Unicode编码值
chr(i)			# 返回i这个值所对应的字符

示例:
在这里插入图片描述

整数转换为字符串函数

hex(i) # 将整数转换为十六进制的字符串
oct(i) # 将整数转换为八进制字符串
bin(i) # 将整数转换为二进制字符串

字符串的构造(创建)函数 str

str(obj = ‘’) # 将对象转换为字符串
示例:

s = 123
print(str(s) + '456') 			# '123456'

str(None)				# 'None'

常用字符串方法

字符串方法的调用语法:对象.方法名(方法传参)
注:方法的调用属于表达式,通常可以返回一个None

S.isdigit()			# 判断字符串中的字符是否全为数字
S.isalpha()			# 判断字符串是否全为英文字母
S.islower()			# 判断字符串所有字符是否全为小写英文字母
S.isupper() 		# 判断字符串所有字符是否全为大写英文字母
S.isspace()			# 判断字符串是否全为空白字符

S.center(width[, fill])		# 将原字符串居中,左右默认填充空格
S.count(sub[, start[, end]])		# 获取一个字符串中子串的个数
S.find(sub[, start[, end]])			# 获取字符串中子串sub的索引,失败返回-1

S.strip()			# 返回去掉左右空白字符的字符串
S.lstrip()			# 返回去掉左侧空白字符的字符串
S.rstrip()			# 返回去掉右侧空白字符的字符串

S.upper()			# 生成将英文转换为大写的字符串
S.lower()			# 生成将英文转换为小写的字符串

S.replace(old, new[, count]) 		# 将原字符串的old用new代替,生成一个新的字符串
S.startwith(prefix[, start[, end]])		# 返回S是否是以prefix开始,如果以prefix开始返回True
S.endswith(suffix[, start[, end]])		# 返回S是否是以suffix结尾,如果以suffix结尾返回True

S.title()			# 生成每个英文单词的首字母大写字符串
S.isnumeric()		# 判断字符串是否全为数字字符
help(str)			# 查看字符串的文档帮助

空白字符是指空格,水平制表符(\t),换行符(\n)等不可见的字符。

字符串格式化表达式

运算符: %
作用:生成一定格式的字符串
语法:
格式字符串 % 参数值
格式字符串 % (参数值1, 参数值2, …)
格式字符串中 % 为占位符,占位符的位置将用参数值替换
示例:

fmt = "姓名: %s, 年龄: %d"

name = input("请输入姓名: ")
age = int(input("请输入年龄: "))

s = fmt % (name, age)
'name: %s, age: %d' % ('cat', 1)
"aaaa%dddd" % 10

格式化字符串中的占位符和类型码

占位符 意义
%s 字符串,使用str函数转换
%r 字符串,使用repr函数转换
%c 整数转为单个字符
%d 十进制整数
%o 八进制整数
%x 十六进制整数(a-f小写)
%X 十六进制整数(A-F大写)
%e 指数型浮点数(e小写) 如:2.8e+10
%E 指数型浮点数(E大写) 如:2.9E + 10
%f, %F 浮点进十制形式
%g, %G 十进制形式浮点数或指数浮点数自动转换
%% 等同于一个%字符

占位符和类型码之间的格式语法

% [格式语法] 类型码
格式语法:- 左对齐
+ 显示正号
0 补零
宽度(整数)
宽度*精度(整数)
示例:

'%10d' % 123			# ‘       123'
'%-10d' % 123			# '123       '
'%10s' % 'abc'			# '       abc'
'%-5s' % 'abc'			# 'abc  '
'%05d' % 123			# '00123'
# 宽度 精度
'%7.3f' % 3.1415926		# '  3.142'
# 输入三行文字,让这些文字一次以最长字符的宽度右对齐输出
s1 = input("Please input string1: ")
s2 = input("Please input string2: ")
s3 = input("Please input string3: ")

m = max(len(s1), len(s2), len(s3))

fmt = "%%%ds" % m
print(fmt)
print(fmt % s1)
print(fmt % s2)
print(fmt % s3)

while语句

作用:根据一定条件,重复的执行一条语句或多条语句
语法:
while 真值表达式:
语句块1
else:
语句块2
while 语句语法说明:

  1. 先执行真值表达式,判断True/False
  2. 如果为True则执行语句块1 ,然后跳转到第一步
  3. 如果为False则执行else子句部分的语句块2,然后结束此while语句
  4. else子句部分可以省略(同if语句类似)
    while注意事项:
    (1)要注意控制真值表达式来避免死循环
    (2)通常用真值表达式内变量来控制循环条件
    (3)通常要在循环语句块内改变循环变量来控制循环的次数和变量的走向

while语句嵌套

while 语句本身是语句,和其他语句一样可以放在其它复合语句内部
while嵌套示意:
while 真值表达式1:

while 真值表达式2:

else:

else:

示例:

# 用while实现打印三角形,要求输入一个整数表示三角形的高度
	
h = int(input("Please input height"))

# 第一种三角形
i = 1
while i <= h:
	print(' ' * (h - i) + '*' * i)
	i = i + 1
else:
	print()

# 第二种三角形
j = h
while j >= 1:
	print('*' * j + ' ' * (h - j))
	j = j - 1
else:
	print()

break 语句

作用:用于循环语句(while, for语句)中,用来终止当前循环语句的执行
break 说明:
(1)当break语句执行后
,此循环语句break之后的语句将不再执行
(2)break语句通常和if语句组合使用
(3)break语句终止循环时,循环语句else子句的语句将不会再执行
(4)break语句只能终止当前循环语句的执行,如果有循环嵌套时,不会跳出嵌套的外重循环
(5)break语句只能在循环语句(whlie或for)语句内部使用
示例:

n = int(input("please input a number: "))

j = 1
while j <= n:
	pass
	i = 1
	while i <= n:
		print(i, end=' ')
		i = i + 1
	else:
		print()

	if j == 4:
		break

	j = j + 1

死循环

死循环是指循环条件一直成立的循环;死循环通常用break语句来终止循环;死循环的else子句永远不会执行。
示例:

sum = 0

while True:
	n = int(input("Please input n"))
	if n < 0:
		break
	sum = sum + n
print(sum)

for 语句

作用:用来遍历可迭代对象的数据元素
可迭代对象是指能依次获取数据元素的对象,可迭代对象包括:
字符串:str
列表:list
元祖:tuple
字典:dict
集合:set

for语句语法:
for 变量列表 in 可迭代对象:
语句块1
else:
语句块2
for 语法说明:
(1) 可迭代对象每次提供一个元素依次赋值给变量列表中的变量,赋值完毕后执行语句块1,重复执行此步骤,知道可迭代对象不能提供数据为止。
(2) 可迭代对象提供完所有的元素后,执行else子句部分的语句块2,然后退出此for语句。
(3) else 子句部分可以省略(同while类似)
(4) 当在循环内部用break终止循环时,else子句部分语句不会执行。
示例:

# 计算一个输入的字符串中有多少个空格
s = input("input a string")
count = 0

for ch in s:
    if ch == ' ':
        count = count + 1

print(count)

range 函数

help(range)
函数:range(stop)从零开始,每次生成一个整数后加1操作,知道stop为止(不包含stop)
range(start, stop[, step]),从start开始,每次生成一个整数后移动step,直到stop为止(不包含stop,且step可以是负整数)。
作用:用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)
说明:range返回的对象是可迭代对象,可以用于for语句中
示例:

range(4)            # 生成0,1,2,3
range(3, 6)         # 生成3,4,5
range(1, 10, 2)     # 生成1,3,5,7,9
range(5, 0, -2)     # 生成5,3,1
range(4, 0)         # 空

for i in range(101):
    if i * (i + 1) % 11 == 8:
        print(i)

for 语句的嵌套

for 语句内部可以放任何语句,包括for语句和while语句

示例:

w = 5
k = 1
for i in range(1, w+1):
    for j in range(k, w + k):
        print(j, end=' ')
    else:
        print()
    k = k + 1

continue 语句

作用:用于循环语句(while, for 语句)中,不再执行此次循环内continue之后的语句,重新开始一场新的循环
说明:
(1) 在while 语句中,执行continue语句将会直接跳转到while语句的真值表达式处重新判断循环条件
(2) 在for语句中,执行continue语句,将会从可迭代对象中取下一个元素,绑定变量后再次进行循环
示例:

# 打印出偶数
begin = int(input("input number1: "))
end = int(input("input number2: "))

for i in range(begin, end + 1):
    if(i % 2 == 1):
        continue
    else:
        print(i)

示例:

# 用在while语句中
i = -1
while i < 10:
    if i % 2 == 1:
        i = i + 1
        continue
    else:
        print(i)
        i = i + 1

列表 list

列表是由一系列特定元素组成的,元素和元素之间没有任何关联关系,但他们之间有先后顺序关系;
列表是一种容器;
列表是序列的一种;
列表是可以被改变的序列

python中序列类型简介(sequence)

字符串:str
列表:list
元祖:tuple
字节串:bytes
字节数组:bytearray

创建一个空列表
L = [ ] # L绑定空列表
创建一个非空列表:
L = [1, 2, 3, 4]
L = [“A”, “B”, “C”, “D”]
L = [1, “two”, 3, “四”]
L = [1, 2, [3.1, 3.2, 3,3], 4]
列表中元素个数:len(L)
示例:

# 列表的构造(创建)函数

list()          # 生成一个空列表,等同于[ ]
list(iterable)  # 用可迭代对象创建一个列表

L = list()                   # []
L = list("ABCD")            # ['A', 'B', 'C', 'D']
L = list(range(1, 10, 2))   # [1, 3, 5, 7, 9]

列表的运算

列表的算术运算

示例:

算术运算: + += * *=
+ 用于拼接列表:
x = [1, 2, 3]
y = [4, 5, 6]
z = x + y       # [1, 2, 3, 4, 5, 6]

+= 用于原列表与左侧可迭代对象进行拼接,生成新的列表, 右侧必须是可迭代对象
x = [1, 2, 3]
x += [4, 5, 6]      # [1, 2, 3, 4, 5, 6]

x = [1, 2, 3]
x += ["ABC"]      # [1, 2, 3, 'ABC']

x = [1, 2, 3]
x += "ABC"     # [1, 2, 3, 'A', 'B', 'C']


* 生成重复的列表
x = [1, 2, 3] * 2       # [1, 2, 3, 1, 2, 3]

*= 生成重复的列表,同时用变量绑定新列表
x = [1, 2, 3]
x *= 3          # [1, 2, 3, 1, 2, 3, 1, 2, 3]
列表的比较运算

示例:

运算符:
< <= > >= == !=
x = [1, 2, 3]
y = [2, 3, 4]
x != y              # True
x > [1, 2]          # True
x < y               # True
[1, 3, 2] > [1, 2, 3]       # True
['AB', 'CD'] > ['AC', 'BD']     # False
[1, 'two'] > ['two', 1]         # TypeError, 数字不能和字符串比较

列表的基本操作

列表的in/not in

判断一个数据元素是否存在于容器(列表)内,如果存在返回True,否则返回False,not in的返回值与in运算符相反。
示例:

x = [1, 'Two', 3.14, '四']
1 in x						# True
2 in x						# False
3 not in x					# True
'四' not in x				# False
列表的索引(index)和切片(slice)操作

列表的索引取值语句:列表[整数表达式]
用法:列表的索引取值与字符串的索引取值规则完全相同;列表的索引分为正向索引和反向索引
示例:

L = ['A', 2, 'B', 3]
print(L[1])				# 2
print(L[2])				# 'B'

列表的索引赋值语句:
列表是可变的序列,可以通过索引赋值改变列表中的元素
语法:列表[索引] = 表达式
示例:

x = [1, 2, 3, 4]
id(x)
x[2] = 3.14				# [1, 2, 3.14, 4] 改变了第三个元素
id(x)

在这里插入图片描述
内存的地址不变,说明列表中原始的第三个变量被替换了而不是重新生成了列表。

列表的切片

列表[:]
列表[::]
列表的切片值返回一个列表,规则等同于字符串的切片规则
示例:

x = list(range(9))
y = x[1:9:2]            # [1, 3, 5, 7]
y = x[:]                # [0, 1, 2, 3, 4, 5, 6, 7, 8]
y = x[5::2]             # [5, 7]
列表的切片赋值语法

列表[切片] = 可迭代对象
说明:切片赋值的赋值运算符右侧必须是一个可迭代对象
示例:

L = [2, 3, 4]
L[0:1] = [1.1, 2.2]             # [1.1, 2.2, 3, 4]

L = [2, 3, 4]
L[:] = [7, 8]                   # [7, 8]

L = [2, 3, 4]
L[1:2] = [3.1, 3.2, 3,3]        # [2, 3.1, 3.2, 3, 3, 4]

L = [2, 3, 4]
L[1:1] = [3.1, 3.2, 3.3]        # [2, 3.1, 3.2, 3.3, 3, 4] 在原列表中增加元素

L = [2, 3, 4]
L[3:3] = [5, 6]        # [2, 3, 4, 5, 6] 在原列表后增加元素

L = [2, 3, 4]
L[0:0] = [0,1]        # [0, 1, 2, 3, 4] 在原列表起始位置增加元素

L = [2, 3, 4]
L[1:2] = []                   # [2, 4] 删除列表中的元素

L = [1, 2, 3, 4, 5, 6, 7, 8]
L[1::2] = [2.2, 4.4, 6.6, 8.8]          # [1, 2.2, 3, 4.4, 5, 6.6, 7, 8.8]  切片步长不为1的切片规则

切片注意事项:
对于步长不为1的切片赋值,赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数。
如:
L = [1, 2, 3, 4, 5, 6]
L[::2] = ‘ABCD’ # 错的
L[::2] = ‘ABC’ # 对的

列表的del语句

del语句用于删除列表中的元素
语法:del 列表[索引]
del 列表[切片]
示例:

L = [1, 2, 3, 4, 5, 6]
del L[0]                # [2, 3, 4, 5, 6]
del L[-1]               # [2, 3, 4, 5]

L = [1, 2, 3, 4, 5, 6]
del L[::2]              # [2, 4, 6]
python3 中常用的序列函数
len(x)          # 返回序列的长度
max(x)          # 返回序列的最大值元素
min(x)          # 返回序列的最小值元素
sum(x)          # 返回序列中所有元素的和(元素必须是数值类型)
any(x)          # 真值测试,如果列表中其中一个值为真值则返回True,否则返回False
all(x)          # 真值测试,如果列表中所有值都为真值,则返回True,否则返回False
常用的列表方法
L.index(v[, begin[, end]])			# 返回对应元素的索引下标,begin为开始索引,end为结束索引,当value不存在时触发ValueError错误
L.insert(index, obj)				# 将某个元素插放到列表中指定位置
L.count(x)							# 返回列表中元素的个数
L.remove(x)							# 从列表中删除第一次出现在列表中的值
L.copy()							# 复制此列表(只复制一层,不会复制深层对象)
L.append(x)							# 向列表中追加单个元素
L.extend(lst)						# 向列表中追加另一个列表
L.clear()							# 清空列表,等同于L[:] = []
L.sort(reverse=False)				# 将列表中的元素进行排序,默认顺序按值的小到大顺序排列
L.reverse()							# 列表的反转,用来改变原序列的先后顺序
L.pop([index])						# 删除索引对应的元素,如果不加索引,默认删除最后元素,并返回删除的元素