python elseif用法_python学习笔记（一）

0、前言

本文是根据廖雪峰python教程学习总结而来。 参考《python学习手册》，《流畅的python》以及python官方手册等网络资料
略过了与C和C++ 语言相同的语法部分

1、转义方式

python的字符串可以用双引号和单引号，作用是相同的。转义的方式和C差不多。不同的是，如果想让一个字符串里面的字符都不用转义的话，可以在字符串前面加字母r来声明。
例如

r'tttt'

里面的内容都无需转义。
或者使用3个引号来把字符串包起来，这样也不需要转义了，而且中间还可以换行。
例如

'''123ttt'''

2、字符串的占位符

百分号占位符

和C语言一样，都是使用百分号占位，但是不同的是，python里面占位符对应的数据也需要百分号来标志，而且占位符对应的数据与字符串之间不需要加逗号。
例如

print ("我叫%s,今年%d岁，工作%d年了" %('冰封飞飞', 18, 2))

format格式化占位符

还有一种新的占位符使用{0}占位，有点像C#的格式化字符串操作。 python官方手册str.format部分

print('{0:,.3f} {1},{name}, {2},'.format(99999.12345, '嘎嘎',[1,2,3,4], name='123'))

输出：

99,999.123 嘎嘎,123, [1, 2, 3, 4],

3、布尔值

True False表示真假，布尔运算是and or not，这点与C语言不同

4、if判断

与C语言不同的是，if和else后面都加冒号，else if变成了elif…

a = 10
b = 20
if a > b :
    print (a > b)
elif a == b:
    print (a == b)
else:
    print (a < b)

5、除法运算

C语言中，两个整数相除的结果还是整数，而在python中，结果是一个浮点数。
如果想让两个整数相除的结果变成整数的话，需要用地板除的方式，双斜线
例如：

10//3

结果是3

6、list

list有点像是C++ 中的vector，可以动态的添加和删除元素。是一个有序的表。可以对一个list使用len来获取长度。与C++ 不同，C++ 是强类型的语言，vector中只能包含相同类型的元素，而python的list中可以包含不同类型的对象，还可以包含另一个list。
list使用中括号来表示
例如：

['123', '234', '345]

通过索引访问list时，还可以使用负数，-1就是取最后一个元素

a=['123', '234', '345']  
a[-1]

输出345
在后面追加元素，相当于C++ 中vector的push_back，在python中是append
例如

a.append('666')

在中间插入元素，相当于C++ 的insert，在python也是insert 例如a.insert(1, '777') 在索引号1的地方插入'777' 在末尾删除元素，相当于C++ 的pop_back，在python中是pop 例如

a.pop()

删除指定索引的元素，在C++ 中无法通过索引直接删除vector的元素，需要使用迭代器，在python中也用pop删除指定位置的元素
例如

a.pop(1)

删除索引1的元素

stack

python中没有单独的stack对象，可以使用list作为stack然后只使用append和pop方法来模拟入栈出栈

queue

队列在queue.Queue中

import queue
q = queue.Queue()
q.put(1)
num = q.get() #获取元素，然后删除元素
q.empty()

7、tuple

tuple类似于C++ 中的tuple，和python的list也很像，只不过tuple一旦创建就不能更改里面的内容了。
tuple可以隐式转换为单个变量例如：

a, b, c = (1, 2, 3)
print(a, b, c)

输出：

1 2 3

也可以使用封包

first, *rest = (1,2,3,4)
print(first)
print(rest)

输出

1
[2, 3, 4]

8、输入输出

输出函数和C语言类似使用

print ("hello world")

输入函数与C和C++ 都比较不同，使用input来获取输入的内容 例如

name = input("input your name")

9、数字字符串转换

在C和C++ 中数字转字符串比较麻烦，一般在C语言中可以使用sprintf。C++ 直接使用to_string。 字符串转数字的话，C语言可以使用atoi，C++ 可以使用stringstream。 在python中可以直接使用int() float() str()转换 例如：

a = int('123')
b = float('12.3)
c = str(123.3)

10、循环

python中有两种循环，一种是for循环一种是while循环。和C、C++ 中的不太一样。没有do while循环
for循环：类似于C++中的for (auto i : vec)这种range-based的for循环

for x in range(10):
    print(x)

while循环：和C、C++中的while循环类似

while x < 10:
    print(x)
    x += 1

python的循环中同样可以使用continue和break来终止循环

11、字典dict

字典类似与C++ 中的unordered_map，是一种哈希表的key-value的查找结构。
使用大括号来表示：

score = {"Mike":100, "冰封飞飞":100, "Fvck":88}

判断一个key在不在字典里面可以使用
"冰封飞飞" in score
返回结果是True或者False
删除一个元素使用pop方法。score.pop("冰封飞飞")
插入一个元素和C++一样直接可以score["new"] = 100
查找操作可以使用get操作，因为如果key不存在的时候，直接使用score["nonexist"]会报错。
get操作还可以指定默认值，如果查找不到key的话，返回默认值

s = {}
print(s.get('a', '3'))

结果：

3

遍历dict：

for (k, v) in score.items():
    print("%s:%d" % (k, v))

12、集合set

集合类似与C++ 中的unordered_ser，是一种哈希表的集合结构。
如果要创建set，需要提供一个list作为输入集合。
s = set([1, 2, 2, 3]) 初始化时，自动会去重元素。
结果是s = {1, 2, 3}
添加元素使用add方法，删除元素使用remove方法

s.add(4)
s.remove(4)

集合类似于数学上的集合，有交集和并集的操作，
s1 & s2, s1 | s2

13、函数

函数名是一个指向函数对象的引用，下面可以直接将函数赋值一个别名

a = abs
a(-10)

而且函数名本身也是一个变量，可以赋值

abs = 10
abs(-10)

这样执行的话，abs(-10)就会报错了。

python包含了很多内置的函数，可以从python官方手册查看
函数的定义使用def

def myFunc(a, b):
    return a + b

空语句可以使用pass，类似于C/C++ 中的分号
可变参数：在参数前面加一个星号，就变成了可变参数，可以传入任意个数的参数，实际上是自动封装成了一个tuple。

可变参数

def myFunc(*num):
    result = 0
    for i in num:
    result += i
    return result

调用时可以myFunc(1, 2, 3)这样调用， 也可以传入一个list或者tuple

param = [1, 2, 3]
myFunc(*param)

关键字参数

def func(a, b, **kw):
    print(kw)

这个函数里面第三个参数是**kw，实际上是一个字典。
调用时可以这样调用：func(1, 2, name="123", age=18)
参数传进去时，实际上a = 1, b = 2 kw = {"name":"123", "age":18}
也可以直接传一个dict作为第三个参数，但是前面需要加两个星号

kw =  {"name":"123", "age":18}
func(1, 2, **kw)

关键字参数必须跟在位置参数后面。下面的调用方式是不合法的。

def func(a, b=1, c=2):
    print(a, b, c)
func(a=1, 2)

命名关键字参数：

def func(a, b, *, name, job):
    print(name)
    print(job)

在上面关键字参数，无法控制**kw传入的key是什么。使用关键字参数可以控制可以传入哪些key。需要使用一个星号作为分隔符。星号后面定义可以传入的key的名称。

func(1, 2, name="1", job=2)  -> OK
func(1, 2, job = 3) -> ERROR

这个星号必不可少，如果正好有一个可变参数，那就不需要额外的星号了
def func(a, b, *args, name, job):也是可以的

参数组合

定义函数的时候可以使用多重参数组合，定义的顺序是，必选参数，默认参数，可变参数，命名关键字参数和关键字参数

def f1(a, b = 0, *args, **kw)
def f2(a, b = 0, *, d, **kw)

对于任意的函数都可以使用一个tuple和一个dict来组织参数调用。类似于func(*args, **kw)

函数注释/注解

函数注释是3.X新加入的功能，可以给函数每一个参数添加一个注释，以及标记返回值的类型。

def func(a:'spam', b:(1,10),c:float=2.5) -> int:
    return a + b + c

注解实际上是把上面添加的内容，写入到了函数的__annotations__方法中。 可以使用

print(func.__annotations__)

打印函数注解，结果如下

{'a': 'spam', 'b': (1, 10), 'c': <class 'float'>, 'return': <class 'int'>}

匿名函数lambda

lambda比def功能要小，lambda仅能编写简单的函数，连if也不能使用，也不能写return，返回值就是表达式的结果

f = lambda x, y, z : x + y + z

装饰器

装饰器是一种委托的调用方式，将被装饰的函数包装一层，增加一些定制处理。 装饰器的用法如下，@log是一个语法糖，相当于test = log(test)，将test函数替换为wrapper函数。
@functools.wraps(func)是系统帮忙做的一些处理，可以让装饰后的函数和原函数看起来一致。例如：包装后的函数__name__还是显示和原函数一致，不会显示为wrapper函数的__name__

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('<trace {0}: {1}({2})>'.format(time.ctime(), func.__name__, args, kw))
        return func(*args, **kw)
    return wrapper
@log
def test(a):    
    print('test func:{0}'.format(a))    
def main():
    test(5)
if __name__ == '__main__':
    main()

结果：

<trace Fri Oct  5 22:10:38 2018: test((5,))>
test func:5

偏函数

偏函数类似与C++ 中的bind，可以将函数的某些参数固定下来，生成一个新的函数。

import functools
int2 = functools.partial(int, base=2)
print(int2('10101'))

结果：

21

14、切片

通过切片操作可以很方便的将list,tuple,string中一段对象取出来。python没有提供substr的函数，字符串的取子串的操作都使用切片来进行

L = list(range(10))
print("L = %s " % L)
print("L[0:3] = %s " % L[0:3])
print("L[:3]= %s " % L[:3])
print("L[-2:] = %s " % L[-2:])
print("L[-2:-1] = %s " % L[-2:-1])
print("L[:10:2] = %s " % L[:10:2])
print("L[:] = %s " %  L[:])

结果：

L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
L[0:3] = [0, 1, 2]
L[:3]= [0, 1, 2]
L[-2:] = [8, 9]
L[-2:-1] = [8]
L[:10:2] = [0, 2, 4, 6, 8]
L[:] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

切片是一个左闭右开的区间，例如L[0:3]，获取[0, 3)区间的元素。
第二个冒号之后的数字是步长，可以相隔步长来取数
只包含一个冒号就是获取变量本身

15、迭代

python的迭代使用for，10循环中说过一些for的内容。类似于C++ 的for(auto i : vec)这种形式的迭代。不是基于下标迭代。

迭代字典dict

d = {'a' : 1, 'b' : 2}
for key in d:
    print (key)
for value in d.values():
    print (value)
for k, v in d.items():
    print('%s : %d' % (k, v))

输出结果：

a
b
1
2
a : 1
b : 2

对于字典，for迭代只会迭代key，如果迭代value的话需要使用d.values()作为迭代对象。如果迭代key-value的话，需要使用d.items()作为迭代对象 判断一个变量是否能迭代，使用下面代码判断。

from collections.abc import Iterable 
d = {'a' : 1, 'b' : 2}
print(isinstance(d, Iterable))
print(isinstance(1, Iterable))

输出

True
False

下标循环

使用enumerate可以将一个可迭代的对象转换为下标+对象的tuple来迭代

from collections.abc import Iterable 
d = {'a' : 1, 'b' : 2}
for i in enumerate(d.items()):
    print(i)

输出

(0, ('a', 1))
(1, ('b', 2))

这个迭代器我用的是i一个元素，这时候i就变成了一个tuple，如果使用两个元素的话，会将这个tuple拆分到两个元素上面去 例如改为：

for i, v in enumerate(d.items()):
    print('%s : %s' % (i, v))

结果就是

0 : ('a', 1)
1 : ('b', 2)

应用迭代的函数

sorted

对参数进行排序

L = [3, 2, 4, 1]
L = sorted(L)
print (L)

结果

[1, 2, 3, 4]

zip

将参数相同索引的数据组成一个tuple，如果几个参数的数量不同，按最小的算

L = [1, 2, 3, 4]
S = ['a', 'b', 'c', 'd', 'e']
Z = zip(L, S)    
print (list(Z))

结果

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

enumerate

将参数返回一个索引+数据的tuple

S = ['a', 'b', 'c', 'd', 'e']    
print (list(enumerate(S)))

结果

[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e')]

filter

将可迭代对象按照参数1,进行过滤。

def isInt(x):
    if isinstance(x, int):
        return True
    else:
        return False
def main():    
    S = [1, 2, 3.0, 4.1, '5', (6,)]
    print (list(filter(isInt, S)))
if __name__ == "__main__":
    main()

结果

[1, 2]

map

类似于C++ 中的使transform，用参数1中的函数，对后面的参数进行迭代运算，如果后面迭代对象数量不一致，按最小的算。

def add(x, y):
    return x + y
def main():    
    S = [1, 2, 3.0, 4.1]
    L = [2, 3, 4, 5, 6]
    print (list(map(add, S, L)))
if __name__ == "__main__":
    main()

结果

[3, 5, 7.0, 9.1]

reduce

类似于C++ 中的accumulate,使用参数1中的函数，对后面的参数进行累加运算，得到一个结果。

from functools import reduce
def main():    
    d = reduce(lambda x, y : x + y, range(101))
    print(d)
if __name__ == "__main__":
    main()

结果

5050

sum

对参数求和

any

对参数全部进行or运算

all

对参数全部进行and运算

max

求参数最大值

min

求参数最小值

欢迎大家关注我们的公众号，一起学习、探讨