0%

萌新的python记录

这个是长期更新的,记录我自己的 python 学习笔记,当然我也是刚学没多久的

所以咳咳,没什么特别的地方

以下开始正文

python的语法和使用相关
先从一个文字游戏来分析吧

1
2
3
4
5
6
7
8
9
print('----------------这是一个文字游戏哈哈哈-----------------')
temp = input("你来猜下现在我抽到的数字:")
guess = int(temp)
if guess == 6:
print("wdnmd,你是偷看了把")
print("老实交代")
else:
print("哈哈,弄错了,数字是6")
print("GAME OVER!")

==print:== 作用是把括号里面的内容打印出来

==input:== 内置函数,把里面的内容打印出来而且把输入值返回给temp

int的作用是把temp里面的东西变成整型。之后temp的值被返回给guess,然后比较。
代码缩进很重要,因为一起执行的代码要一样的缩进方式,不然不一样的缩进方式会没用的!

==BIF=Built-in functions== 意思是内置函数

python并不是把值存储在变量中,更像是把名字贴在值的上面
注意

  • 在使用变量前,需要先对其赋值
  • 变量名可以是大写或小写,但是大小写是不同的
  • 变量名可以包括字母,数字,下划线,但变量名不能以数字开头
  • 等号(=)是赋值的意思,左边是名字,右边是值,不能搞反了

如果要创建字符串,就要在字符两边加上引号,可以是单引号或者双引号,但是必须成对。 如果字符串包含引号的话,可以用转义符号 \来进行。

1
2
3
4
例子  
Let\'s go
```
还有个办法是在字符串前面加一个英文字母 **r** 即可

str = r’C:\now’

1
对于长字符串来说,要用三重引号来实现

str = ‘’’ C\dfdf\gf\hgh ‘’’

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
python比较操作符  

```python
> 左边大于右边
>= 左边大于等于右边
< 左边小于右边
<= 左边小于等于右边
== 左边等于右边
!= 左边不等于右边

关于返回值,返回True意思是真的。返回False意思是假的
```
==TAB==是代码缩进的快捷键

**and**操作符,当两边都是结果都是**True**时,输出**True**。如果有一边结果是**False**,那么输出就是**False**
**or**操作符,只要两边有一边为真,就输出**True**,如果两边都是假,那就输出**False**
**not**操作符,输出相反的结果

```python
示例如下
(3>2)and (1<2) 左右两边都是正确的时候
True

(3>2) and (1>2) 有一边是错误的时候
False
============================================
(3>2) or (4>5) 只要有一边正确就输出正确
True
============================================
not 0 0表示False,在not的作用下输出了Ture
True

python的数据类型
==Ture== 表示1
==False== 表示0

==int()== 表示转换成整数型
==str()== 表示转换成字符串
==float()== 表示转换成浮点数

获得类型信息的方法
==type()== 在括号里面输入数据就可以了
==isinstance== 使用方法在下面

1
2
3
4
5
6
a = '憨憨'
isinstance(a,str)
True

a表示你要知道类型的,str则是类型名
如果下面出现的是True的话,表示a就是str类型的数据

python的运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
大部分运算符和其他语言一样

// 这个除法运算符会把结果变成整型
** 这个运算符的意思是平方,a**3 就是a的3次方

但是运算可以简化的
比如

a*3

可以简化成

a*=3
1
2
3
4
5
6
7
8
9
10
11
优先级问题,第一个是最高优先级

幕运算 **

正负号 +x -x

算术操作符 * / // + -

比较操作符 < <= > >= == !=

逻辑运算符 not and or

python的分支和循环

==elif:== 这相当于C语言里的else if,但是注意下这些循环什么的后面要加上:才可以正常使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
例子
判断成绩属于什么层次

score = int(input('输入成绩'))
if 100 >= score >= 90:
print('A')
elif 90 > score >= 80: 这里的elif就是else if的意思
print('B')
elif 80 > score >= 60: 注意ifelse等等这些后面要加:才行
print('C')
elif 60 > score >= 0:
print('D')
else:
print('非法输入')

条件表达式(三元操作符)

1
2
3
4
5
6
7
8
9
10
11
用这个可以实现一条语句实现条件判断和赋值操作

原来
x,y = 4,5
if x < y: 如果x大于y
small = x 把x的值赋给small
else: 如果不是
small = y 把y的值赋给small

改进后
small = x if x < y else y

断言
assert这个关键字被称为“断言”,当这个关键字后面的条件为假的时候,程序自动崩溃并抛出AssertionError的异常

1
2
3
4
5
例子
assert 3 > 4

一般来说,当需要确保程序中某个条件一定为真的时候,才能让程序
正常工作的话,assert关键字就很有用了

for循环

1
2
3
4
语法是

for 目标 in 表达式:
循环体

range语法
包含range([strat,] stop[, step=1])

  • 有三个参数,其中用中括号括起来的表示这两个参数是可选的 。
  • step=1表示第三个参数的值默认是1 。
  • range的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列。
  • 当然range里面的数字是可以自己定义范围的,比如range(2,9)就是包含了数字2~8
  • 还有种情况,range(1,10,2)意思是把1~9包含,但是每两个数字之间相隔2,也就是说包含了1,3,5,7,9这些数字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
range(5)
>>> range(0,5)

list(range(5)) <--这样是把它用列表方式打印出来
>>> [01234]

for循环的配合

for i in range(5)
print(i)

0 <——结果就是这样
1 < for循环会把range里的
2 < 打印出来
3
4

break 和 continue
continue:当条件不成立,退出循环体;条件成立,继续执行。


==列表==
向列表里添加元素的方法是,使用append实现
比方说向member数组里面添加emm

1
2
3
4
5
6
7
例子
member.append('emmm')

还有
len可以获取数组包含的元素个数

len(member) 括号里填的是数组名字

如果要添加多个的话,就要用到extend
比如向 member 添加两个元素(emmm 和 emm)

1
2
3
注意添加的时候要用中括号来括起来

member.extend(['emmm','emm'])

假使你要把元素放到数组的指定位置上,就要使用insert
比如把 first 放到数组第一个去。

1
2
3
4
括号里的 0 表示的是放到数组里的位置是第几个
'' 里面的则是添加的元素

member.insert(0,'first')

==从列表里删除元素==
使用remove语法实现的

1
2
3
'' 里面就是输入你要删除的元素

member.remove('emm')

使用del语法实现的

1
2
3
4
[] 里面的数字是你要删除的元素的位置,就是第几个的意思
如果只是执行 del member 那就会删除整个member列表

del member[1] <----示例

还有,使用pop语法可以把列表最后一个元素踢出来

1
2
3
4
5
6
member.pop()      而且被踢出的元素会显示出来

因为会显示出来,相当于有返回值,所以可以把踢出来的值
赋值给另一个列表

name = member.pop() 就是把踢出的元素赋给name

==列表分片==
快速从列表里提取出元素,但是不会改变被提取列表

1
2
3
4
5
6
中括号里的就是要提取的元素范围

member[1:3] <--- 提取12号元素

如果是 [:] 的话,那么就是得到一个列表的拷贝,因为这相当于提
取第一个到最后一个元素

==列表的常用操作符==

  • 比较操作符
1
2
3
4
5
6
7
8
9
10
11
列表可以通过下面的比较符来进行比较
list1 > list2
list1 = list2
list1 < list2
如果正确就是 Ture ,错误就是False

如果列表里有多个元素的话,拿去比较的是第一个元素
list1 = [111,222]
list2 = [222,111]
list1 > list2 <---比较的是每个列表的第一个元素
结果是 False
  • 逻辑操作符
1
就是 and 这些
  • 连接操作符
1
2
3
4
有 list1 和 list2 两个列表
如果想把两个列表拼接到一起

list3 = list1 + list2 <--- list3就是拼接好的列表
  • 重复操作符
1
2
3
4
5
6
list3 *=3

意思是把列表 list3 给复制了三遍
如果 list3 = [1,2,3]
那么执行上面的命令后就是
list3 = [1,2,3,1,2,3,1,2,3]
  • 成员关系操作符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
11 in list1
意思是查询 list1 列表里有没有元素 11 ,如果有返回Ture,没有
就返回False

11 not in list1
意思是 11 元素不在列表 list1 里面,正确返回Ture,错误
返回False

但是注意,如果列表里面还包含列表的话,那么上面那个就无效了
如果想要的话,就要使用另一个方法

22 in list1[1]
中括号里的数字是第几个列表的意思(从0开始)

list1[1][1]
意思是访问 list1 数组中,第[1]个数组的第[1]个元素,并返回值
  • 计数
    通过count来实现
1
2
3
list1.count(123)
意思是记录元素 123 在 list1 这个列表里出现了多少次,并返回
出现次数
  • index用法
1
2
3
4
5
6
list1.index(123)
意思是返回元素 123 在列表 list1 中的位置

list1.index(123,3,7)
意思是寻找第3~7号元素里 123 的位置,并返回
如果范围里出现多次 123 ,那么返回的就是第一次出现的位置
  • reverse用法
1
2
3
list1.reverse
意思是把列表 list1 给反转,通俗的讲就是第一个变倒数第一个
倒数第二个变第二个
  • sort用法
1
2
3
4
5
6
list1.sort()
意思是把列表 list1 的元素从小到大排序

list1.sort(reverse=True)
意思是把列表 list1 的元素从大到小排序。
其实就是把执行 sort() 的结果反转过来了

==元组==
由于和列表是近亲关系,所以元组和列表在实际使用上是非常相似的
操作符也可以通用

  • 创建和访问一个元组
    注意元组的标志性符号是,
1
2
3
4
tuple1 = (1,2,3,4)
这样就创建了一个名为 tuple1 的元组

但是元组是不可以修改的!
  • 更新一个元组
    如果要给一个元组里添加元素
1
2
3
4
5
6
7
8
temp = ('dsad','ffa',222,'dff')
这是一个元组,现在要向里面添加元素 nmd

temp = temp[:2] + ('nmd',) + temp[2:] <---就是这样
里面的 2 是你要添加的位置, nmd 则是添加进去的元素

原理是把元组 temp 拆成两部分,然后把元素添加进去,然后给
新元组贴上 temp 标签,旧元组被抛弃
  • 删除元组里的元素
1
2
del temp
意思就是删除名字为 temp 元组

==各种奇葩的内置方法(字符串)==

  • 如果要查询某个位置的元素
1
2
3
4
5
6
7
str1 = 'nmd wsm'    <-- 一个字符串

str1[ :6]
这样会提取出 0~5 号元素并返回

str1[5]
这样会把排在第5号的元素返回
  • 插入元素
    字符串和元组一样是不能轻易修改的
1
2
3
4
5
6
7
8
str1[ :6] + '插入的字符串' + str1[6: ]
用这个方法来把元素插入到指定的位置

但是这相当于弄了个新的字符串,原来的那个 str1 的内容还是
没有改变

str1 = str1[ :6] + '插入的字符串' + str1[6: ]
这样子才可以
  • capitalize() 用法
1
2
3
4
5
6
7
str2.capitalize()
意思是把 str2 字符串里的第一个字符变成大写

示例
str2 = 'xiaoxie'
str2.capitalize()
>>> Xiaoxie <--- 看,第一个字符变成了大写
  • casefold() 用法
1
2
3
4
5
6
7
把整个字符串的所有字符改为小写

str2 = 'DAXIE'
str2.casefold()
>>> daxie <--全部变成小写了

但是注意这返回的是一个新的字符串,并没有改变 str2 的内容
  • center(width) 用法
1
2
3
4
5
将字符串居中,并使用空格填充至长度 width 的新字符串

str2.center(40)
>>>' daxie '
可以看到字符串被居中了,而且左右两边空的距离为 40
  • count(sub[,start[,end]]) 用法
1
2
3
4
5
6
返回 sub(这个自己选) 在字符串里出现的次数
start 和 end 参数表示统计的范围,可选(如果没有就是整个字
符串里统计)

str2.count('xi')
意思是查找字符 xi 在字符串里出现的次数,并返回
  • endswith(sub[,start[end]]) 用法
1
2
3
4
5
6
7
8
检查字符串是不是以 sub(自己定义) 结束,如果是就返回True
不是就返回False
同样 start 和 end 参数表示统计的范围,可选(如果没有就
是整个字符串里统计)

str2.endswith('xie')
>>> True <-- 如果字符串是以 xie 结尾
>>> False <-- 如果字符串不是以 xie 结尾
  • expandtabs([tabsize=8]) 用法
1
2
3
4
5
6
把字符串里的 tab 符号(\t)转换成空格,如果不指定参数
默认空格数就是 tabsize=8

str3 = 'wdnmd\t233\temm' <-- 创建字符串 str3
str3.expandtabs() <-- 没有指定参数,所以就是使用默认参数
>>>wdnmd 233 emm <-- \t 都变成了8个空格
  • find(sub[,start[,end]]) 用法
1
2
3
4
5
6
7
8
检查 sub(自己定义) 是不是包含在字符串中,如果有返回索引值
否则返回-1
同样 start 和 end 参数表示统计的范围,可选(如果没有就
是整个字符串里统计)

str3.find('nfc')
>>> -1 <-- 没有找到返回-1
>>> 如果找到就是返回它的位置
  • index(sub[,start[,end]]) 用法
1
2
和上面的 find 使用方法一样
唯一的不同在于如果没有找到就会报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
下面这些发用法和 find 的使用方法一样

isalnum() <-- 如果字符串至少有一个字符并且所有字符都
是字母或数字则返回True,否则返回False

isalpha() <-- 如果字符串至少有一个字符并且所有字符都
是字母则返回True,否则返回False

isdecimal() <-- 如果字符串只包含十进制数字则返回True
否则返回False

isdigit() <-- 如果字符串只包含数字则返回True,否则
返回False

islower() <-- 如果字符串至少包含一个区分大小写的字符
,并且这些字符都是小写,则返回True,否则返回False

isnumeric() <-- 如果字符串只包含数字字符,则返回True
否则返回False

isspace() <-- 如果字符串只包含空格,则返回True,否则
返回False

istitle() <-- 如果字符串是标题化(所有单词以大写开
始,其余都是小写),则返回True,否则返回False

isupper() <-- 如果字符串至少包含一个区分大小写的字符
并且这些字符都是大写,则返回True,否则返回False
  • jojn(sub) 用法
1
2
3
4
5
6
以字符串为分隔,插入到 sub 中所有的字符之间,并返回

str1 = 'emm' <-- 创建一个字符串
str1.jojn('1234') <-- sub 可以替换成你想插入的字符
>>> 1emm2emm3emm4
结果就是这样
  • ljust(width) 用法
1
2
返回个左对齐的字符串,并用空格填充至长度为 width 的新字符串
用法参考 center(width)
  • lower() 用法
1
转换字符串中所有大写字符为小写
  • lstrip() 用法
1
2
3
4
5
6
7
8
去掉字符串左边的所有空格并返回

str1 = ' emmm' <-- 创建字符串
str1.lstrip()
>>> emmm


rstrip() 这个则是相反的,它是删除字符串末尾的空格
  • partition(sub) 用法
1
2
3
4
5
6
7
找到子字符串 sub ,把字符串分成一个3元组(pre_sub,sub,fol_sub)
如果字符串不包含 sub 则返回('原字符串','','')

str1 = 'a bign boss' <-- 创建字符串
str1.partition('ig') <-- 设定为 ig
>>> ('a b','ig','n boss')
可以看到字符串被分成了3个元组
  • replace(old,new[,count]) 用法
1
2
3
4
5
6
7
把字符串中的 old 子字符串替换成 new 子字符串,如果 count 指定,则替换不超过 count 次
count 可以不指定

str1 = 'bili old' <-- 创建字符串
str1.replace('old','new')
>>> 'bili new'
可以发现原来的 old 被替换成了 new
  • rfinf(sub,[,start[,end]]) 用法
1
类似于 find() 的用法,不过是从右边开始查找
  • rindex(sub,[,start[,end]]) 用法
    1
    类似于 index() 的用法,不过是从右边开始查找
  • rjust(width) 用法
1
返回一个右对齐的字符串,并使用空格填充至长度为 width 的新字符串
1
2
3
rpartition(sub)         <-- 类似 partition() 方法,不过是从右边开始查找

rstrip() <-- 删除字符串末尾的空格
  • split(sep=None,maxsplit=-1) 用法
1
2
3
4
5
6
7
8
9
10
11
12
13
不带参数默认是以空格为分隔符切片字符串,如果 maxsplit 参数有设置,则仅分隔 maxsplit 个子字符串,并返回切片后的子字符串拼接的列表

如果没参数的情况下
str1 = 'we are family' <-- 创建字符串
str1.split() <-- 没有设置参数
>>> ['we','are','family']
发现它以空格为标识来切片

如果有参数的情况下
str1 = 'i love fishc' <-- 创建字符串
str1.split('i') <-- 设置参数为 i
>>> ['',' love f','shc']
可以看到以 i 为标识来切片,而 i 则是被切没了
  • splitlines(([keepends])) 用法
1
按照 '\n' 分隔,返回一个包含各行作为元素的列表,如果 keepends 参数指定,则返回前 keepends 行
  • startswith(prefix[,start[,end]]) 用法
1
2
3
检查字符串是否以 prefix 开头,是则返回True,否则返回False

使用方法以及注意事项和上面的 endswith(sub[,start[,end]]) 一样
  • strip([chars]) 用法
1
2
3
4
5
6
7
8
9
10
删除字符串前边和后边所有的空格并返回, chars 参数可以指定范围(可选)

str1 = ' ssaass ' <-- 创建字符串
str1.strip() <-- 不指定参数
>>> 'ssaass'
可以发现字符两边的空格被删除了

str1.strip('s') <-- 指定参数 s 字符
>>> 'aa'
发现两边的 s 字符都被删除了
  • swapcase() 用法
1
2
3
4
5
6
翻转字符串中的大小写并返回

str1 = 'Add' <-- 创建字符串
str1.swapcase()
>>> 'aDD'
可以看到大小写被翻转了
  • title() 用法
1
2
3
4
5
6
返回标题化(所有的单词都是以大写开始,其余字母均小写)的字符串

str1 = 'lAST' <-- 创建字符串
str1.title()
>>> 'Last'
可以看到除了首字母大写外,其他的都变成小写了
  • translat(table) 用法
1
2
3
4
5
6
7
8
9
根据 table 的规则(可以由 str.maketrans('a','b')定制)转换字符串中的字符

str1 = 'sssssaaaassss' <-- 创建字符串
str1.translate(str.maketrans('s','b')) <-- 把所有 s 字符变成 b 字符
>>> 'bbbbbaaaabbbb'
可以看到字符 s 都变成了字符 b

str.maketrans('s','b') <-- 如果只这样输入
{115:98} <-- 就会返回 s 和 b 的ASCII编码
  • upper() 用法
1
2
3
4
5
6
转换字符串中的所有小写字符为大写

str1 = 'last' <-- 创建字符串
str1.upper()
>>> 'LAST'
可以看到都变成了大写
  • zfill(width) 用法
1
2
3
4
5
6
返回长度为 width 的字符串,原字符串右对齐,前边用0填充

str1 = 'last'
str1.zfill(10) <-- width 参数指定为10
>>> '000000last'
可以看到返回了长度10的字符串,前面用0来填充

格式化

1
2
3
4
5
6
'{0} love {1}.{2}'.format('I','Fishc','com')
>>> 'I love Fishc.com'
可以看到 format 后面的字符被插入进去了。依照 {} 里面的数字编号

除此之外还有一种方法,用字母来代替数字
'{a} love {b}.{c}'.format(a='I',b='Fishc',c='com')
1
2
3
'{0:.1f}{1}'.format(27.658,'GB')
>>> '27.7GB'
其中的 :.1f 意思是四舍五入保留一位小数并打印,所以 27.658 就变成了 27.7

字符串格式化符号含义

  • %c 用法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    格式化字符及其ASCII码

    '%c' % 97 <-- 对 97 使用该符号
    >>> 'a'
    可以看到 97 变成了其在 ASCII 里面对应的字符

    如果对进行多次操作,最好用 () 括起来
    '%c %c %c' % (97,98,99)
    >>> 'a b c'
  • %s 用法
1
2
3
4
5
格式化字符串

'%s' % 'I love Fishc.com'
>>> 'I love Fishc.com'
相当于通过这个把字符串合并进去
  • %d 用法
1
2
3
4
5
格式化整数

'%d + %d = %d' % (4 , 5, 4+5)
>>> '4 + 5 = 9'
相当于把括号里的数字打印出来
  • %o用法
1
2
3
4
5
6
7
8
9
格式化无符号八进制数

'%o' % 10
>>> '12'
可以看到把 10 变成了八进制数字 12 并返回

扩展
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数(大写) <-- 因为十六进制数包含英文字母,这个意思是把字母都变成大写
  • %f 用法
1
2
3
4
5
6
7
8
格式化定点数,可指定小数点后精度

'%f' % 27.658
>>> '27.658000'
因为 %f 默认是6位。所以位数不够会用 0 补齐

'%.1f' % 27.658 <-- .1表示留一位,数字可以自定义
>>> '27.7'
  • %e 用法
1
2
3
4
5
6
7
用科学计数法格式化定点数

'%e' % 27.658
>>> '2.765800E+01' <-- 返回值用科学计数法表示了
E+01 表示的意思是 10 的一次方

还有种表示方式是 '%E'
  • %g%G 用法
1
2
3
4
5
其实这两个一样的
根据值的大小决定使用 %f 或 %e

'%g' % 27.658
>>> '27.658'

格式化操作符辅助命令

  • m.n 用法
1
2
3
4
5
m 是显示的最小总宽度,n 是小数点后的位数

'%5.1f' % 27.658 <-- m 被指定位5,n 被指定为1
>>> ' 27.7'
5 是表示整个字符串宽度为5,而 1 则是表示小数点后只有一位数
  • - 用法
1
2
3
4
5
用于左对齐

'%-10d' % 5
>>> '5 '
可以看到 5 被左对齐了
  • + 用法
1
2
3
4
在正数前面显示加号。如果是个负数则原样输出

'%+d' % 5
>>> '+5'
  • # 用法
1
2
3
4
5
6
7
在八进制数前面显示零(' 0'),在十六进制数前面显示 ' ox' 或者 ' OX'

'%#o' % 10
>>> '0o12' <-- 0o 表示它是八进制数 12

'%#X' % 108
'0X6C' <-- 0X 表示它是十六进制数 6C
  • 0 用法
1
2
3
4
5
6
7
8
9
显示的数字前面填充 '0' 取代空格

'%010d' % 5 <-- 10 的意思是填充100
>>> '0000000005'
可以看到前面被填充了100

'%-010d' % 5 <-- 如果多加一个 - 符号
>>> '5 '
发现改成后面填充空格了

字符串转义字符含义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

\' 单引号

\" 双引号

\a 发出系统响声(实际并不会)

\b 退格符

\n 换行符

\t 横向制表符(TAB)

\v 纵向制表符

\r 回车符

\f 换页符

\o 八进制数代表的字符

\x 十六进制数代表的字符

\0 表示一个空字符

\\ 反斜杠

序列

1
2
3
4
5
6
7
8
9
列表、元组和字符串的共同点

-- 都可以通过索引得到每一个元素

-- 默认索引值总是从0开始

-- 可以通过分片的方法得到一个范围内的元素的集合

-- 有很多共同的操作符(重复操作符、拼接操作符、成员关系操作符)
  • list() 用法
1
2
3
4
5
6
7
8
9
10
把一个对象转换成列表

a = list() <-- 如果不带参数
>>> []
就是一个空列表

a = 'add big boss' <-- 给 a 添加元素
a = list(a) <-- 参数选择为 a
>>> ['a', 'd', 'd', ' ', 'b', 'i', 'g', ' ', 'b', 'o', 's', 's']
字符串 a 通过 list 变成了一个每个字符单独出来的列表
  • tuple([iterable]) 用法
1
2
把一个对象转换成元组
使用方法和 list 一样
  • str(ojb) 用法
1
把 ojb 对象转换为字符串
  • max() 用法
1
2
3
4
5
6
返回序列或者参数集合中的最大值

numbers = [1,18,13,0,-98,34,54,76,32]
max(number)
>>> 76
返回了 numbers 里面最大的数值
  • min() 用法
1
2
返回序列或者参数集合中的最小值
使用方法和 max() 一样
  • sum(iterable[,start=0]) 用法
1
2
3
4
5
6
7
8
9
10
11
返回序列 iterable 和可选参数 start 的总和

tuple = (3.1,2.3,3.4)
sum(tuple)
>>> 8.8
把 tuple 里面的数值总和返回

a = (1,2,3,4)
sum(a,10) <-- 如果添加
>>> 20
那么就会在原 a 的总和(10)后再加上 10,返回值
  • sorted() 用法
1
2
3
4
5
6
把参数从小到大排序并返回

a = [23,3423,123,445,632,452,35]
sorted(a)
>>> [23, 35, 123, 445, 452, 632, 3423]
a 里面的参数被从小到大排序了
  • reversed() 用法
1
2
3
4
5
6
a = [23,3423,123,445,632,452,35]
reversed(a)
>>> <list_reverseiterator object at 0x0000029322767A00>
返回了迭代器对象

list(reversed(a)) <-- 用这个可以逆转回来
  • enumerate() 用法
1
2
3
4
5
6
7
a = [23,3423,123,445,632,452,35]
enumerate(a)
<enumerate object at 0x0000029322769080>

list(enumerate(a)) <-- 使用逆操作
>>> [(0, 23), (1, 3423), (2, 123), (3, 445), (4, 632), (5, 452), (6, 35)
发现每一个元素都变成了元组,并且前面都有索引值
  • zip() 用法
1
2
3
4
5
6
7
8
9
10
返回由各个参数的序列组成的元组

a = [1,2,3,4,5,6,7,8]
b = [4,5,6,7,8]
zip(a,b)
>>> <zip object at 0x0000029322769080>

list(zip(a,b)) <-- 使用逆操作
>>> [(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]
发现 a 和 b 合在一起了,每两两元素组成一个元组,但是这是成对存在的,所以多出的部分被省略了

函数:python的乐高积木

1
2
3
4
5
6
7
8
9
10
11
12
13
def MyFirstFunction():
print('这是我创建的第一个函数!')
print('我表示很激动')

def 就是定义了一个函数,而 :后面则是函数的执行体

如何调用一个函数
MyFirstFunction() <-- 直接输入函数名字
>>> 这是我创建的第一个函数!
我表示很激动
这样就是调用了这个函数

其实实现的原理就是 def 定义了一个叫 MyFirstFunction() 的函数,然后调用这个函数的话就会执行这个函数里面的内容
1
2
3
4
5
6
7
8
同时可以给函数一个参数
def MyFirstFunction(name): <-- 给了一个参数 name
print(name + '表示很激动')
但是注意这里是不能直接调用的,因为需要一个参数

MyFirstFunction('你爸爸') <-- 调用的时候给一个参数 '你爸爸'
>>> 你爸爸表示很激动
这才是正确的调用方法
1
2
3
4
5
6
7
如果是多个参数

def add(num1,num2):
result = num1 + num2 <-- result 的值等于 num1 + num2
print(result)
add(1,2) <-- 调用函数 add ,参数给定 12
>>> 3

函数的返回值

1
2
3
4
5
6
使用 return 

def add(num1,num2):
return (num1 + num2) <-- 使用 return 返回 num1 + num2 的值
print(add(5,6)) <-- 给定参数 56,并打印结果
>>> 11

收集参数 *

1
2
3
4
5
6
7
8
9
收集参数是使用 * 来定义的

def test(*pa): <- * 就是收集参数
print('参数的长度是:',len(pa));
print('第二个参数是:',pa[1]);

test(1,'apk',222,3.33,2,3,4,5,6)
>>> 参数的长度是: 9
>>> 第二个参数是: apk

形参和实参

1
2
3
4
5
6
7
8
9
10
11
12
13
def MyFirstFunction(name):
'函数的定义过程中的name是叫形参'
print('传递进来的'+ name + '叫做实参,因为TA是具体的参数值!')

当输入的时候
MyFirstFunction('嘿嘿嘿')
>>> 传递进来的嘿嘿嘿叫做实参,因为TA是具体的参数值!

如果要打印出它的属性的话,使用
MyFirstFunction.__doc__

就会打印出
>>> '函数的定义过程中的name是叫形参'

当然还有别的方法也可以打印出 MyFirstFunction 的文档

比如使用 help(MyFirstFunction) 或者 print.__doc__,但是使用前一个方法打印出来的更加美观

关键字参数

开始举例

1
2
def SaySome(name,words):
print(name + '->' + words)

然后进行调用,打印出效果

1
2
3
SaySome('你是谁','我是谁')

>>> 你是谁->我是谁

但是如果参数的位置反了的话,打印出来的结果也会不一样,所以可以给参数加上关键字来防止

1
2
3
SaySome(words='我是谁',name='你是谁')

>>> 你是谁->我是谁

可能看起来像是多此一举,但是当以后代码量变得多起来的是hi,你就会发现这个其实很有用的

默认参数

默认参数是定义了默认值的参数

1
2
def SaySome(name='我是谁',words='你是谁'):
print(name + '->' + words)

当你调用的时候,没给参数它也不会报错,因为它是有默认参数的

1
2
3
SaySome()

>>> 我是谁->你是谁

但是,你也可以给它参数

1
2
3
SaySome('你好','我好')

>>> 你好->我好

当你没有给定参数的时候它就会使用默认参数,防止你忘了给参数导致报错

收集参数

1
2
3
def test(*params):
print('参数的长度是:',len(params));
print('第二个参数是:',params[1]);

当你调用并输入时

1
2
3
4
test(1,'你好啊',3.14,5,6,7,8)

>>> 参数的长度是: 7
>>> 第二个参数是: 你好啊

注意是从 0 开始数的哈,不是从 1 开始

但是需要注意的一点是,如果收集参数的后面你还要加上其它参数的话,那么在调用的时候就应该使用关键字参数,不然 python 就会把后面的也列为收集参数的范畴了

举个例子,如果我们在后面加上一个参数

1
2
3
def test(*params,exp):
print('参数的长度是:',len(params),exp);
print('第二个参数是:',params[1]);

然后再调用

1
2
3
4
5
6
test(1,'你好啊',3.14,5,6,7,8)

Traceback (most recent call last):
File "<pyshell#32>", line 1, in <module>
test(1,'你好啊',3.14,5,6,7,8)
TypeError: test() missing 1 required keyword-only argument: 'exp'

就会发现报错了,那是因为它会把前面所有内容都给收集参数,那么 exp 参数就得不到内容了。如果想要正常运行的话,那应该使用默认参数

1
2
3
4
5
6
7
8
9
def test(*params,exp):
print('参数的长度是:',len(params),exp);
print('第二个参数是:',params[1]);

在调用的时候给exp指定一个值,这样就可以了
test(1,'你好啊',3.14,5,6,7,8,exp = 8)

>>> 参数的长度是: 7 8
第二个参数是: 你好啊

函数与过程

1
2
3
4
5
6
7
8
def hello():
print('Hello ppt')

将其赋值给
temo = hello()

打印结果
>>> Hello ppt

但是如果只输入 temo

1
2

发现什么也没有打印出来

因为 hello 这个函数并没有返回任何东西,自然也没有东西可以给 temo,所以不会显示

如果你想强行弄出来,可以输入 print(temo)

1
>>> None

如果没有值,那么它也会返回一个 None

返回值

如果想要 python 返回多个值,可以使用列表来实现

1
2
3
4
5
6
7
8
def back():
return [1,'哈哈',6.66]

输入
back()

返回
>>> [1, '哈哈', 6.66]

不过也可以不加上 (),改成这种写法

1
2
3
4
5
6
def back():
return 1,'哈哈',6.66


打印结果
>>> (1, '哈哈', 6.66)

全局变量和局部变量

1
2
3
4
5
6
7
8
def discounts(price,rate):
final_price = price * rate
return final_price

old_price = float(input('请输入原价:'))
rate = float(input('请输入折扣率:'))
new_price = discounts(old_price,rate)
print('打折后的价格是:',new_price)

在这里试图打印局部变量的值,在最后加入代码

1
2
3
4
5
6
7
8
9
def discounts(price,rate):
final_price = price * rate
return final_price

old_price = float(input('请输入原价:'))
rate = float(input('请输入折扣率:'))
new_price = discounts(old_price,rate)
print('打折后的价格是:',new_price)
print('打印局部变量final_price的值:',final_price)

但是报错了,那是因为 final_price 是一个局部变量,因为它的生效范围只在 discounts 函数里,如果出了这个范围,那它就是无效的。
这就是局部变量,只在局部范围里生效

与局部变量相对于的是全局变量,全局变量的作用域是整个代码

下面尝试打印全局变量的值

1
2
3
4
5
6
7
8
9
def discounts(price,rate):
final_price = price * rate
print('这里试图打印全局变量old_price的值',old_price)
return final_price

old_price = float(input('请输入原价:'))
rate = float(input('请输入折扣率:'))
new_price = discounts(old_price,rate)
print('打折后的价格是:',new_price)

运行后会发现,值被成功打印出来了

但是如果在函数内试图修改一个全局变量,那么 python 会自动创建一个新的局部变量代替,名字和全局变量是一模一样的

总结:全局变量在整个代码里都是可以被访问得到的

但是不要尝试在函数内部去修改它,因为那样的话python会自动新建一个名字一模一样的局部变量去代替


内嵌函数和闭包

前面提到过,不要在函数内部去修改全局变量,但是如果你一定要修改的话,可以使用 global 关键字

1
2
3
4
5
6
7
先定义全局变量
count = 5

def MyFun():
global count <- 使用 global 关键字来修改全局变量 count
count = 10
print(10)

内嵌函数

1
2
3
4
5
def fun1():
print('fun1()正在被调用...')
def fun2():
print('fun2()正在被调用...')
fun2()

输入 fun1(),可以看到打印的结果是

1
2
fun1()正在被调用...
fun2()正在被调用...

可以看出 python 是支持函数的嵌套的,fun1() 里面套了个 fun2()

需要注意的是内部函数的整个作用域都在外部函数之内

简单的说就是如果你输入 fun2() 的话,它是会报错的,因为 python 是访问不到内部函数的

闭包

我们可以将闭包理解为一种特殊的函数,这种函数由两个函数的嵌套组成,且称之为外函数和内函数,外函数返回值是内函数的引用,此时就构成了闭包。

1
2
3
4
5
6
7
8
9
10
def FunX(x):
def FunY(y):
return x * y
return FunY

调用
FunX(8)(5)

打印的结果是
>>> 40

注意的是因为闭包是由内部函数的定义演变而来,所以不能在外部函数的外面对内部函数进行调用

下面就是一个错误例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def Fun1():
x = 5
def Fun2():
x *= x
return x
return Fun2()

当你输入
Fun1()

就会报错
Traceback (most recent call last):
File "<pyshell#30>", line 1, in <module>
Fun1()
File "<pyshell#29>", line 6, in Fun1
return Fun2()
File "<pyshell#29>", line 4, in Fun2
x *= x
UnboundLocalError: local variable 'x' referenced before assignment

这是因为内部函数无法访问到 x 的值,所以报错中提示到没有定义。如果想要正确执行这个,那就要使用元组

1
2
3
4
5
6
def Fun1():
x = [5]
def Fun2():
x[0] *= x[0]
return x[0]
return Fun2()

这个时候在输入 Fun1(),就可以打印正确的结果了

当然还有额外的方法,不使用元组

1
2
3
4
5
6
7
def Fun1():
x = 5
def Fun2():
nonlocal x
x *= x
return x
return Fun2()

添加 nonlocal 即可,这样做的目的是把 x 强制声明为全局变量


lambda表达式

先来个例子

1
2
3
4
5
6
7
8
def ds(x):
return 2 * x + 1

输入
ds(5)

打印结果
>>> 11

我们可以使用 lambda 表达式对其进行简化

1
2
3
4
5
6
7
g = lambda x : 2 * x + 1

输入
g(5)

打印结果
>>> 11

看上去使用 lambda 后减少了 def 过程,不用再为函数的命名而烦恼了。因为 lambda 返回的是一个没有名字的函数,我们只需要给函数一个名字然后赋值就可以使用了

而当不使用后,它就会自动删除

lambda 还可以使用多个参数

1
2
3
4
5
6
7
g = lambda x,y : x+y

输入
g(3,4)

打印结果
>>> 7

lambda表达式的作用

  • python写一些执行脚本时,使用 lambda 就可以省下定义函数的过程,可以让代码更加简洁
  • 对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数,有时候给函数起个名字也是头疼的问题,使用 lambda 就不需要考虑命名问题了
  • 简化代码的可读性,

filter

这是一个过滤器,它会把任何非true的内容都给过滤掉

1
2
3
4
list(filter(None,[1,0,False,True]))

打印的结果是
[1, True]

当然你也可以自己来定义要过滤掉什么,比如弄一个过滤掉奇数的过滤器

1
2
3
4
5
6
7
8
9
10
11
12
13
首先定义函数
def odd(x):
return x % 2

temp = range(10)

show = filter(odd,temp)

输入
list(show)

最后显示列表里的奇数
[1, 3, 5, 7, 9]

但是使用 lambda 语句就可以简化这个过程

1
list(filter(lambda x : x % 2,range(10)))

这个的打印结果和上面的是一样的,但是代码却压缩到只有一句

map()

一般解释为映射,会根据提供的函数对指定序列做映射

继续举例

1
2
3
4
list(map(lambda x : x * 2,range(10)))

打印的结果为
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

map 在里面起到的作用是,将函数和后面 range 里的元素进行运算,并把结果放到函数的参数里

最后返回的值就组成了一个序列


递归

首先来一个用递归求阶乘的

  • 正整数阶乘指从1乘以2乘以3乘以4一直乘到所要求的数
  • 例如给的数是5,则阶乘是1X2X3X4X5,得到的积是120,所以120就算4的阶乘

下面是实现的代码,但是不是用递归

1
2
3
4
5
6
7
8
9
10
def factorial(n)
result = n
for i in range (1,n)
result *=i

return result

number = int(input('请输入一个正整数:'))
result = factorial(number)
print('%d 的阶乘是 %d' % (number,result))

下面的才是递归版的(虽然没必要用递归,因为python限制了层数为100,如果输入过大会崩溃)

1
2
3
4
5
6
7
8
9
def factorial(n)
if n == 1:
retuen 1
else:
return n * factorial(n-1)

number = int(input('请输入正整数:'))
result = factorial(number)
print('%d 的阶乘是 %d' % (number,result))

虽然使用递归可以让代码精炼,但是也要小心,因为它对内存和时间的消耗很大,

----------------本文结束感谢阅读----------------
如果觉得文章好的话,就打个赏吧!
隐藏