字符串与函数
- 一、字符串
- 内建函数
- 格式化字符串
- 二、函数
- 定义与调用
- 匿名函数
- 常用实参高阶函数
一、字符串
在python中，字符串是用’，”，’’’，”””引起来的内容被称为字符串，书写方式是str。
内建函数
字符串的主要难点还是在一些杂七杂八的内建函数上，在这里我对字符串的用法做了整理，当然对这些函数的使用还是多多益善。
x为某个字符串
函数 | 含义及用法 |
’ '.join(x) | 用空格拼接x |
len(x) | 长度 |
max(x) | 最大的字母 |
min(x) | 最小的字母 |
x.capitalize() | 第一个字符转大写 |
x.center(width) | 将str居中在某个长度的字符串里，width必须要写 |
x.count(str) | str 出现次数 |
x.encode(encoding=‘’) | 以指定的编码格式编码字符串 |
x.endswith(str) | 是否以str结束 |
x.find(str) | str 是否包含在字符串中，包含则返回开始的索引值，否则返回-1 |
x.index(str) | 同 find()，如果str不在则报错 |
x.isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False |
x.isalpha() | 至少有一个字符并且所有字符都是字母或中文字符 |
x.isdigit() | 只包含数字 |
x.islower() | 是否都为小写 |
x.isnumeric() | 是否都为数字 |
x.istitle() | 是否标题化 |
x.isupper() | 是否都为大写 |
x.ljust(width, fillchar) | 左对齐,用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
x.lower() | 大写转小写 |
x.lstrip() | 删除x左边的空格 |
x.replace(old, new, num) | 把x中的old 替换成 new，替换 num 次 |
x.rfind(str) | 同 find()，从右边开始 |
x.rindex(str) | 同 index()，从右边开始 |
x.rjust(width) | 同 x.ljust()，右对齐 |
x.rstrip() | 同 lstrip()，从右边开始 |
x.split() | 以空格为分隔符截取x到列表中 |
x.splitlines() | 同 split()，按行分隔 |
x.startswith(str) | 同 endswith()，开头 |
x.strip() | 同 lstrip()，开头和结尾 |
x.swapcase()) | 大小写互转 |
x.title() | 标题化 |
str.maketrans(str1, str2) | 根据 str1 和 str2 创建字符映射的转换表，为一个字典 |
x.translate(trantab) | 根据转换表 trantab 翻译 x |
x.upper() | 小写转大写 |
x.zfill (width) | 同 rjust()，填充0 |
x.isdecimal() | 是否只包含十进制字符。这种方法只存在于unicode对象。**注意:**定义一个十进制字符串，只需要在字符串前添加 ‘u’ 前缀即可。 |
以下代码帮助说明
>>> x = 'hello world'
>>> x.center(20)
' hello world ' # 居中，空格填充
>>> x.zfill(20)
'000000000hello WORLD' # 右对齐，0填充
>>> x.endswith('d')
True
>>> x.find('world')
6
>>> x.isalnum() # 包含空格
False
>>> x.upper()
'HELLO WORLD'
>>> x.split()
['hello', 'world']
>>> type(x.split())
<class 'list'>
>>> x = 'hello WORLD'
>>> ' '.join(x)
'h e l l o W O R L D'
>>> x.swapcase()
'HELLO world'
>>> x.title() # 每个单词都变
'Hello World'
>>> str1 = 'heloWORLD'
>>> str2 = '123456789'
>>> x.translate(str.maketrans(str1, str2))
'12334 56789'isdecimal()的用法
>>> u'7654dtytr'.isdecimal()
False
>>> u'1234567'.isdecimal()
True
>>> '1234567'.isdecimal()
True
>>> x = 1234567 # 不带引号
>>> x.isdecimal()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'isdecimal'
>>> x = '1234567' # 带引号
>>> x.isdecimal()
True格式化字符串
1） f’’
2） .format()
3） .format_map()
4） %
常用的字符串占位符：
符号 | 说明 |
%s | 可以给任何类型的数据占位(字符串占位符) |
%d | 只能给数字数据占位（整数占位符） |
%f | 只能给数字数据占位（浮点数占位符, 默认保留6位小数） |
%.Nf | 只能给数字数据占位（保留N位小数） |
>>> weather = "晴天"
>>> hours = '8：30'
# 方法一
>>> f'今天{weather}，现在{hours}了'
'今天晴天，现在8：30了'
# 方法二
>>> '今天{}，现在{}了'.format(weather, hours)
'今天晴天，现在8：30了'
# 方法三
>>> '今天{weather}，现在{hours}了'.format_map(vars())
'今天晴天，现在8：30了'
>>> '今天{weather}，现在{hours}了'.format_map({'weather':'晴天', 'hours': '8：30'})
'今天晴天，现在8：30了'其他控制格式
>>> name = '小花'
>>> age = 25
>>> money = 15000
>>> '%s今年%d岁！月薪：%.2f元' % (name, age, money)
'小花今年25岁！月薪：15000.00元'
>>> money = 672828279
>>> f'余额:{money:.2f}元'
'余额:672828279.00元'
>>> num = 102.3447
>>> f'个数:{num:.0f}'
'个数:102'
>>> money = 16500
>>> f'年薪:{money*13:.2f}元'
'年薪:214500.00元'
>>> money = 165009000
>>> f'金额:{money:,}元'
'金额:165,009,000元' # 大金额逗号分隔
>>> f'金额:{money:,.2f}元'
'金额:165,009,000.00元'
>>> scale = 0.84
>>> f'及格率:{scale:.1%}' # 百分比
'及格率:84.0%'
>>> num = 6
>>> f'{num:x>7}' # > 表示 右对齐，< 表示左对齐，^ 表示居中对齐
'xxxxxx6'
>>> f'{num:x<7}'
'6xxxxxx'
>>> f'{num:x^7}'
'xxx6xxx'
>>> f'编号:{num:>7}'
'编号: 6'
>>> nums = [155, 1, 92, 9, 23, 889, 18, 5821, 47, 8993]
>>> for x in nums:
... print(f'编号:{x:>4}')
...
编号: 155
编号: 1
编号: 92
编号: 9
编号: 23
编号: 889
编号: 18
编号:5821
编号: 47
编号:8993二、函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。 函数能提高应用的模块性,和代码的重复利用率。
- 什么是函数
函数就是实现某一特定功能的代码的封装。
函数将实现某一个或者某类功能的代码打成一个包，以后再需要这个包中的这段代码中对应的功能的时候不用重新写这段代码，而是使用封装了这段代码的函数
- 函数存在的价值：
当一个功能需要反复使用的时候，如果没有函数，每次说需要这个功能就必须把实现这个功能的代码写一遍。如果有函数，实现功能对应的代码只需要写一遍（封装成函数），然后在每次需要这个功能的时候调用实现这个功能的函数。
- 函数的分类
跟据这个函数是由谁创建的，我们将函数分为系统函数和自定义函数两种：
系统函数： 由系统创建的函数（python本身就创建好的函数），例如： print、input、type、max、min等
自定义函数： 由程序员自己创建的函数
定义与调用
- 定义函数（造机器）
语法：
def 函数名(形参列表):
函数说明文档
函数体说明：
def： 关键字，固定写法
函数名： 由程序员自己命名
两个要求：
是标识符
不是关键字
三个规范：
见名知义
所有的字母都小写，多个单词用下划线隔开
不适用系统的函数名、类名和模块(): 固定写法
形参列表：
以’变量名1, 变量名2, 变量名3, …'的形式存在，根据情况变量的数据可以为0（每一个变量就是一个形参）
形参的作用： 将函数外部的数据传递到函数里面
确定形参的方法：看实现函数的功能需不需要额外的数据，需要多少个额外的数据
函数说明文档： 就是多行注释（相当于生活中机器的说明书），例如：
#阶乘
def factorial(num):
“”"
(功能说明区）求一个数的阶乘： num!
:param num:(参数说明）求阶乘的对象
:return:(返回值说明)None
“”"
sum1 = 0
for x in range(1, num + 1):
sum *= x
print(sum1)函数体：
结构上，和 def 保持一个缩进的一条或者多条语句。
逻辑上，函数体就是实现函数功能的代码
def func1():
print('hello world')
def func2():
print(1 + 2)- 调用函数
调用函数（使用函数）
>>> func1()
hello world
>>> func2()
3
函数调用过程：
第一步： 回到函数定义的位置
第二步： 传参（用实参给形参赋值，传参的时候必须保证每个形参都有值）
第三步： 执行函数体
第四步： 确定函数返回值
第五步： 回到函数调用的位置， 接着往后执行
注意：调用函数时括号填入的内容
# 累计和
>>> def sum_n(num):
... sum1 = 0
... for i in range(1, num + 1):
... sum1 += num
... print('1到{}的和为：'.format(num), sum1)
...
>>> sum_n(100)
1到100的和为： 10000
# 提取数字
>>> def get_nums(str1):
... new_str1 = ''
... for x in str1:
... if x.isdigit():
... new_str1 += ''.join(x)
... print('其中的数字有：', new_str1)
...
>>> get_nums('hello 12345 world 67890')
其中的数字有： 1234567890- 函数的参数
位置参数：以 ‘实参1， 实参2， 实参3， …’ 的形式存在，让实参和形参从位置上一 一对应
关键字参数：以 ‘形参1=实参1， 形参2=实参2，…’ 的形式存在，通过’='将实参和形参对应
参数默认值：定义函数的时候可以通过 ‘形参名=数据’ 的方式给形参赋默认值。在调用函数的时候，有默认值的参数可以不用传参
注意：定义函数不会执行函数体
>>> def del_none(list1):
... for i in list1[:]:
... print(i)
... if (not i) and (i != 0):
... list1.remove(i)
... print(list1)
...
>>>
>>> lis = ['', 1, '', 2, [], 3, None, 0]
>>> del_none(lis)
1
2
[]
3
None
0
[1, 2, 3, 0]如果循环写成for i in list1: 结果会怎么样？
>>> def del_none(list1):
... for i in list1:
... print(i)
... if (not i) and (i != 0):
... list1.remove(i)
...
>>>
>>> lis = ['', 1, '', 2, [], 3, None, 0]
>>> del_none(lis)
# 此处打印空值
# 此处打印空值
[]
None
[1, 2, 3, 0]注意循环时元素个数变化引起的错误 1）for i in lis[:]:
表示的是将lis copy了一个新列表进行遍历，每次遍历的列表都是[‘’, 1, ‘’, 2, [], 3, None, 0],所以 i 的值依次为列表中每个元素。
2）for i in lis:
循环次数 | lis | 打印结果 |
0 | [‘’, 1, ‘’, 2, [], 3, None, 0] | ‘’ |
1 | [1, ‘’, 2, [], 3, None, 0] | ‘’ |
2 | [1, 2, [], 3, None, 0] | [] |
3 | [1, 2, 3, None, 0] | None |
4 | [1, 2, 3, 0] | 结束 |
注意：位置参数和关键字参数可以一起用，但是必须保证位置参数在关键字参数的前面
>>> def func3(x=1, y=2, z=3):
... print(x + y * z)
...
>>> func3(x=3, y=4, z=5)
23
>>> func3(x=3, 4, 5)
File "<stdin>", line 1
func3(x=3, 4, 5)
^
SyntaxError: positional argument follows keyword argument
语法错误:位置参数在关键字参数后面- 参数类型说明
没有默认值参数的类型说明：
形参： 类型名有默认值的参数，默认值数据对应的类型就是这个形参的类型
返回值类型说明：
def func() -> str:不定长参数：
*形参
它的本质是一个元组如果定义函数的时候，形参列表中有一个独立的*，调用函数的时候* 后面所有的形参必须使用关键字参数传参
*，形参1， 形参2， …
# 类型说明
>>> def func4(x: str, y=' ') -> str:
... for i in x:
... if i != y:
... print(i, sep='', end='')
...
>>> func4(' he llo\twor ld,I\tlo ve\tC hina. ')
hello world,I love China.
# 不定长参数
>>> def func5(x, y, *args):
... print(args)
... return x ** 2 + y ** 2
...
>>> func5(1, 2, 3, 4, 5)
(3, 4, 5)
5
>>> def sumn(*nums):
... return sum(nums)
...
>>> sumn(1, 2, 3, 4)
10
>>> def func6(x, *, y, z):
... pass
...
>>> func6(10, 20, 30)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: func6() takes 1 positional argument but 3 were given
>>> func6(10, y=20, z=30)
>>> def func7(x, *y, z, t):
... print(x)
... print(y)
... print(z)
... print(t)
...
>>> func7(1,2,3,4,5,6,7,8)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: func7() missing 2 required keyword-only arguments: 'z' and 't'
>>> func7(1,2,3,4,5,6,z=7, t=8)
1
(2, 3, 4, 5, 6)
7
8- 返回值
什么是返回值？
返回就是从函数内部传递到函数外部的数据（Python中的每个函数都可以传递一个数据到函数的外部）怎么确定一个函数的返回值（怎么在函数的内部将数据传递到函数的外部）？
return后面的值就是函数的返回值（执行函数覅的如果遇到return，return后面的值就是函数的返回值）怎么在函数外部货物函数返回值？
获取函数调用表达式的值就是获取这个函数的返回值什么时候使用返回值？
如果实现函数的功能，产生了新的数据，就将新的数据作为函数的返回值返回
没有默认值参数
注意：一个函数只有一个返回值
def func8(a, b):
result1 = a + b
result2 = a * b
return result1
return result2
func8(10, 20)
# 结果只返回 result1注意：函数遇到 return，直接结束
def func9():
print('++++++++++')
print('----------')
return # 相当于 return None
print('==========')
func9()
# 运行结果
++++++++++
----------- 变量作用域
变量在定义完成后可以使用的范围
根据变量作用域的不同，可以将变量分为全局变量和局部变量两种
全部变量：
没有定义在函数里面或者类里面的变量都是全局变量
作用域：从定义开始，到程序结束。（程序结束前的任何位置都可以使用）局部变量：
定义在函数中的变量就是局部变量（形参也是局部变量；定义在类中的变量是属性）
作用域： 从定义开始到函数结束
a = 10 # a 为全局变量
def func10():
print(f'函数中a:' {a})
func10()
for x in range(5):
b = 10 # x 和 b 是全局变量
def func11():
print(f'外面x和b:' {x}, {b})注意：函数外面不能使用函数中定义的局部变量
def func12(c):
d = 30
print(f'函数里面 c 和 d:', {c}, {d})
func12(40) # c 和 d 是局部变量
运行结果：函数里面 c 和 d: 40 30
print(f'c 和 d 的值：', {c}, {d})
运行结果：
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'c' is not defined- 变量作用域
- 全局变量默认保存在全局栈区间(程序结束的时候才会被释放)
局部变量默认是保存在函数对应的临时栈区间中(函数对应的临时栈区间，创建函数的时候会创建出来，函数调用结束会自动释放)。- 在函数中定义变量的时候，可以在定义变量前面加 global 关键字，让函数中定义变量可以保存在全局栈区间中。
x = 100 # 保存全局栈区间
def func4():
y = 200 # 保存在func4对应的临时栈区间
global z
z = 300 # 保存在全局栈区间中- 函数参数的确定
调用函数的时候，实参的数据类型又参数在函数体中的使用方式决定
匿名函数
匿名函数的本质还是函数，但是它只能实现简单的功能(一行语句就能实现它的功能)
语法：
函数名 = lambda 形参列表:返回值
相当于：
def 函数名(形参列表):
return 返回值
应用：
在给实参高阶函数传参的时候，可以使用普通函数函数名，也可以使用匿名函数(能用匿名函数就使用匿名函数，不行才用普通函数)
# 定义一个函数求两个数的和
>>> sum2 = lambda num1, num2: num1+num2
>>> sum2(10, 20)
30
>>> sum2(num1=100, num2=200)
300常用实参高阶函数
- max、min、sorted等
max(序列)
直接比较序列中元素本身的大小，求出最大值。max(序列,key=函数)
按照函数制定的比较规则比较元素的大小，求出最大值
- map
map(函数, 序列)
根据函数制定规则，将指定序列中的元素转换成新序列中的元素map(函数, 序列1, 序列2)
map(函数, 序列1, 序列2, 序列3,…)
- reduce
reduce(函数, 序列, 默认值)
将序列中所有的元素通过指定的规则合并成一个数据
注意：reduce使用之前要先导入
>>> # 示例2：求nums中个位数最大的元素
>>> nums = [18, 23, 67, 90, 56, 49]
>>> result = max(nums, key=lambda item: item % 10)
>>> result
49
>>> # 练习3：nums中各个位数之和最大的元素
>>> nums = [102, 19, 48, 221, 52]
# 102 -> '102' -> '1'、'0'、'2' -> 1 + 0 + 2 = 3
# 3,10,12,5,7 -> 12最大，对应的元素为48
>>> result = max(nums, key=lambda item: sum([int(x) for x in str(item)]))
>>> result
48
# 求所有元素个位数的和
>>> from functools import reduce
>>> nums = [23, 78, 92, 78, 12]
>>> result = reduce(lambda i, item: i + item % 10, nums, 0)
>>> result
23
