python学习

SEVO 实验室

一.变量和字符串

首先：Python 每个语句结束可以不写分号 ;， 如 print(‘hello’) 打印 hello

1.1 变量

变量的命名法：

驼峰式命名法
帕斯卡命名法

1.2 字符串

1、基本介绍

单引号 ‘ ‘或者双引号 “ “ 都可以，再或者 ‘’’ ‘’’ 三个引号，其中三个引号被用于过于长段的文字或者是说明，只要是三引号不完你就可以随意换行写下文字。

①字符串直接能相加，如：

1
2
3
1 str1 = 'hi'
2 str2 = 'hello'
3 print(str + str2)

运行结果：

1
1 hi jaybo

②字符串相乘，如：

1
1 string = 'bang!'

打印 total 结果：

1
1 bang!bang!bang!

2、字符串的分片与索引

字符串可以通过 string[x] 的方式进行索引、分片。

字符串的分片实际可以看作是从字符串中找出来你要截取的东西，复制出来一小段你要的长度，存储在另一个地方，而不会对字符串这个源文件改动。分片获得的每个字符串可以看作是原字符串的一个副本。

先看下面这段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
1 name = 'My name is Mike'
2 print(name[0])
3 'M'
4 print(name[-4])
5 'M'
6 print(name[11:14]) # from 11th to 14th, 14th one is excluded
7 'Mik'
8 print(name[11:15]) # from 11th to 15th, 15th one is excluded
9 'Mike'
10 print(name[5:])
11 'me is Mike'
12 print(name[:5])
13 'My na'

:两边分别代表着字符串的分割从哪里开始，并到哪里结束。
以name[11:14]为例，截取的编号从第11个字符开始，到位置为14但不包含第14个字符结束。而像name[5:]这样的写法代表着从编号为5的字符到结束的字符串分片。相反，name[:5]则代表着从编号为0的字符开始到编号为5但包含第5个字符分片。可能容易搞混，可以想象成第一种是从5到最后面，程序员懒得数有多少个所以就省略地写，第二种是从最前面到5，同样懒得写0，所以就写成了[:5]。

3、字符串的方法

replace 方法：第一个参数表示被替代部分，第二个参数表示替代成怎样的字符串。
字符串填空，如：

1
2
1 city = input("write the name of city:"")
2 url = "http://apistore.baidu.com/mri.../weather?citypiny={}.format(city)

4、问题

Q1

1
2
3
1 num = 1
2 string = '1'
3 print(num + string)

这样会出错
解释：整数型不能和字符串直接相加。可以先把该字符串转为整数型，再相加，即 int(string)

1
2
3
1 num = 1
2 string = '1'
3 print(num + int(string))

二.函数

如

1
2
1 判断数据类型：type(str) 
2 字符串类型数据转为整数型：int(str)

2.1函数格式

def 和 return 为关键字。

注意： 函数缩进后面的语句被称为是语句块，缩进是为了表名语句的逻辑与从属关系。缩进这个问题不能忽视，否则会导致代码无法成功运行，这里需要特别注意。

2.2 函数参数

①位置参数，举例，看代码：

1
2
1 def trapezoid_area(base_up, base_down, height):
2 return 1/2 * (base_up + base_down) * height

接下来我调用该函数：

1
trapezoid_area(1,2,3)

不难看出，填入的参数1，2，3分别对应着参数 base_up，base_down 和 height。这种传入参数的方式被称作为位置参数。

②关键词参数：在函数调用的时候，将每个参数名称后面赋予一个我们想要传入的值，如调用 fun1 函数时候：fun1(a=1, b=2, c=3)。
③不定长参数
有时我们在设计函数接口的时候，可会需要可变长的参数。也就是说，我们事先无法确定传入的参数个数。
Python 提供了一种元组的方式来接受没有直接定义的参数。这种方式在参数前边加星号 * 。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。例如：

1
2
3
4
5
6
7
8
9
10
1 def print_user_info( name ,  age  , sex = '男' , * hobby):
2 # 打印用户信息
3 print('昵称：{}'.format(name) , end = ' ')
4 print('年龄：{}'.format(age) , end = ' ')
5 print('性别：{}'.format(sex) ,end = ' ' )
6 print('爱好：{}'.format(hobby))
7 return;
8
9 # 调用 print_user_info 函数
10 print_user_info( '小明' , 25, '男', '打篮球','打羽毛球','跑步')

输出的结果：

1
1 昵称：小明 年龄：25 性别：男 爱好：('打篮球', '打羽毛球', '跑步')

通过输出的结果可以知道，* hobby 是可变参数，且 hobby 其实就是一个 tuple （元祖）。

可变长参数也支持关键参数，没有被定义的关键参数会被放到一个字典里。这种方式即是在参数前边加 **，更改上面的示例如下：

1
2
3
4
5
6
7
8
9
10
1 def print_user_info( name ,  age  , sex = '男' , ** hobby ):
2 # 打印用户信息
3 print('昵称：{}'.format(name) , end = ' ')
4 print('年龄：{}'.format(age) , end = ' ')
5 print('性别：{}'.format(sex) ,end = ' ' )
6 print('爱好：{}'.format(hobby))
7 return;
8
9 # 调用 print_user_info 函数
10 print_user_info( name = '小明' , age = 25 , sex = '男', hobby = ('打篮球','打羽毛球','跑步'))

输出的结果：

1
1 昵称：小明 年龄：24 性别：男 爱好：{'hobby': ('打篮球', '打羽毛球', '跑步')}

通过对比上面的例子和这个例子，可以知道， hobby 是可变参数，且 hobby 其实就是一个 tuple （元祖），** hobby是关键字参数，且 hobby 就是一个 dict （字典）。
④ 只接受关键字参数
关键字参数使用起来简单，不容易参数出错，那么有些时候，我们定义的函数希望某些参数强制使用关键字参数传递，这时候该怎么办呢？将强制关键字参数放到某个参数或者单个*后面就能达到这种效果,比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
1 def print_user_info( name , *, age, sex = '男' ):
2 # 打印用户信息
3 print('昵称：{}'.format(name) , end = ' ')
4 print('年龄：{}'.format(age) , end = ' ')
5 print('性别：{}'.format(sex))
6 return;
7
8 # 调用 print_user_info 函数
9 print_user_info( name = '小明' ,age = 25 , sex = '男' )
10
11 # 这种写法会报错，因为 age ，sex 这两个参数强制使用关键字参数
12 #print_user_info( '小明' , 25 , '男' )
13 print_user_info('小明',age='22',sex='男')

通过例子可以看，如果 age , sex 不适用关键字参数是会报错的。

2.3 匿名函数

有没有想过定义一个很短的回调函数，但又不想用 def 的形式去写一个那么长的函数，那么有没有快捷方式呢？

——答案是有的。

Python 使用 lambda 来创建匿名函数，也就是不再使用 def 语句这样标准的形式定义一个函数。
匿名函数主要有以下特点：
lambda 只是一个表达式，函数体比 def 简单很多。
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
基本语法：lambda [arg1 [,arg2,…..argn]]:expression
示例：

1
2
1 sum = lambda num1 , num2 : num1 + num2;
2 print( sum( 1 , 2 ) )

输出的结果： 3
注意：尽管 lambda 表达式允许你定义简单函数，但是它的使用是有限制的。 你只能指定单个表达式，它的值就是最后的返回值。也就是说不能包含其他的语言特性了， 包括多个语句、条件表达式、迭代以及异常处理等等。

匿名函数中，有一个特别需要注意的问题，比如，把上面的例子改一下：

1
2
3
4
5
6
7
8
1 num2 = 100
2 sum1 = lambda num1 : num1 + num2 ;
3 
4 num2 = 10000
5 sum2 = lambda num1 : num1 + num2 ;
6 
7 print( sum1( 1 ) )
8 print( sum2( 1 ) )

输出结果：

1
2
1 10001
2 10001

这主要在于 lambda 表达式中的 num2 是一个自由变量，在运行时绑定值，而不是定义时就绑定，这跟函数的默认值参数定义是不同的。所以建议还是遇到这种情况还是使用第一种解法。

三、循环与判断

3.1 布尔表达式和判断

Python 中的布尔类型值：True 和 Flase 其中，注意这两个都是首字母大写。
但凡能够产生一个布尔值的表达式为布尔表达式：

1
2
3
4
5
6
7
1 1 > 2 # False
2 1 < 2 <3 # True
3 42 != '42' # True
4 'Name' == 'name' # False
5 'M' in 'Magic' # True
5 number = 12
6 number is 12 # True

注1：不同类型的对象不能使用<、>、<=、=>进行比较，却可以使用==和!=。
注2：浮点类型和整数类型虽然是不同类型，但不影响比较运算。还有，不等于!= 可以写作<> 。
布尔类型可以比较的 如：True > Flase，回答是可以的，Ture 和 Flase 对于计算机就像是 1 和 0 一样，所以结果是真，即True。

3.2 条件控制

所谓条件成立，指的是返回值为True的布尔表达式