python-易错知识(二)

一.python流程控制
1.if-else

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

使用or/ and/ not:与或非

2.for循环

for循环语法:
for var in sequence:
    statement(s)
迭代序列指数
range():快速生成序列
range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
list() 函数是对象迭代器，把对象转为一个列表。返回的变量类型为列表。
>>> range(100)
range(0, 100)
>>> list(range(10))#不包括结尾
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range(i,j,[,步值])
python3中取消了xrange()函数

3.遍历(迭代)

for x in "abc":
    print(x)

s="abc"
for x in range(len(s)):
    print(s[x])


a
b
c

遍历字典

d={1:111,2:222,4:333}
for k,v in d.items():
    print(k,v)
1 111
2 222
4 333  

4.循环控制

import time
for x in range(300):
    print(x)
    time.sleep(1)
else:
    print("ending")
ctrl+c结束进程
Traceback (most recent call last):
  File "G:\Python\workspace\day02\bianli.py", line 4, in <module>
    time.sleep(1)
KeyboardInterrupt
发现ending并没有执行

break/continue/pass(代码桩，占位)/exit()跳出整个过程

for x in range(1,11):
    print(x)
    if x==6:
        break
else:
    print("ending")
1
2
3
4
5
6

for x in range(1,11):
    print(x)
    if x==6:
        break
else:
    print("ending")
for x in range(1,11):
    print("--------",x)

1
2
3
4
5
6
-------- 1
-------- 2
-------- 3
-------- 4
-------- 5
-------- 6
-------- 7
-------- 8
-------- 9
-------- 10 

for x in range(1,11):
    print(x)
    if x==2:
        print(5555555)
        continue
    if x==6:
        break
else:
    print("ending")
for x in range(1,11):
    print('--------',x)
 1
2
5555555
3
4
5
6
-------- 1
-------- 2
-------- 3
-------- 4
-------- 5
-------- 6
-------- 7
-------- 8
-------- 9
-------- 10 

pass的代码
for x in range(1,11):
    print(x)
    if x==2:
        pass
    if x==6:
        break
1
2
3
4
5
6 
exit()跳出整个过程
for x in range(1,11):
    print(x)
    if x==2:
        pass
    if x==3:
        exit()
    if x==6:
        break

5.while

while 1:
    a=input("请输入x")
    if a=='q':
        break
    print(a)
    print("hello")
else:
    print("ending---")

二.函数
1.函数的定义

函数：工具集/排序/极值
作用：降低编程的难度/代码重用
方式：def 函数名(参数列表):
          函数体
>>> def add():
    c=a+b
    print(c)
>>> a=200
>>> b=300
>>> add()
500
def fun():
    if True:
        print("good")
fun()

2.函数的参数（形参/实参）

缺省参数(默认参数)
def machine(x,y="奶油"):
    print("制作出一个",x,"元",y,"口味冰淇淋")
machine(5,"巧克力")
machine(5)#这个值就是第一位
machine("玫瑰")
machine(90,"玫瑰")
制作出一个 5 元 巧克力 口味冰淇淋
制作出一个 5 元 奶油 口味冰淇淋
制作出一个 玫瑰 元 奶油 口味冰淇淋
制作出一个 90 元 玫瑰 口味冰淇淋

3.局部变量和全局变量
4.函数的return

函数返回值：return 返回值
>>> def f(x,y):
    print("welcome")
    return x+y

>>> f(2,3)
welcome
函数在return之后结束
>>> def f():
    return 5
    return 6

>>> f()
5

5.函数的其他功能(tuple-dict)
默认参数(见上)；多类型传值

--向函数传元组和字典
------fun(*args)
------fun(**kwords)
单参数
        >>> def f(x):
        print(x)
        >>> f(10)
        10
        >>> f("aaaa")
        aaaa
        >>> f([1,2,3,4,5])
        [1, 2, 3, 4, 5]
        >>> f((23,4,5,56))
        (23, 4, 5, 56)
        >>> f({1:111,12:234,13:233})
        {1: 111, 12: 234, 13: 233}

多参数     
传递元组(需要用到一个*号)      
            >>> t=('name','milo')
            >>> def f(x,y):
                    print("%s:%s" % (x,y))


            >>> f(*t)
            name:milo
传递字典(需要用到两个*号)#无序传值，此处需要和字典的key值相同，否则出错
            >>> tt={'age':30,'name':'milo'}#此处需设置默认值
            >>> def f(name='name',age=30):
                print('name:%s'%name)
                print('age:%s'%age)


            >>> f(**tt)

            age:30
            name:milo
            格式化:
            >>> print("%s:%s" %('name','milo'))
            name:milo

-传值冗余(处理多余的实参/多个参数的接受)
--- def fun(*args,**kw)
        >>> def f(x,*args):#此处args为元组
            print(x)
            print(args)


        >>> f(1)
        1
        ()
        >>> f(1,2,3)
        1
        (2, 3)
----- 利用字典映射
        >>> def f(x,*args,**kwargs):
            print(x)
            print(args)
            print(kwargs)


        >>> f(1,2,3,4,5,6,7,8,9)
        1
        (2, 3, 4, 5, 6, 7, 8, 9)
        {}
        >>> f(x=1,y=2)#存在映射关系
        1
        ()
        {'y': 2}
        >>> f(1,2,3,4,x=10,y=20)
        Traceback (most recent call last):
          File "<pyshell#35>", line 1, in <module>
            f(1,2,3,4,x=10,y=20)
        TypeError: f() got multiple values for argument 'x'
        >>> f(1,2,3,4,z=10,y=20)
        1
        (2, 3, 4)
        {'y': 20, 'z': 10}

6.lambda

lambda表达式:
    --匿名函数
    lambda函数是一种快速定义单行的最小函数，是从Lisp借用而来，可以用在
    任何需要函数的地方。
    ----基本模型(冒号前面是参数)
        >>> lambda x,y:x+y
        <function <lambda> at 0x00000202B819DC80>#此处返回的是一个对象
        >>> g=lambda x,y:x+y
        >>> g(2,3)
        5
    ----好处:精简代码;不需要考虑命名的问题;容易理解
    ----应用：
        reduce:逐次操作list里的每项，接时的参数为2个，最后返回一个结果。
            在Python 3里，reduce()函数已经被从全局名字空间里移除了，它现在被放置在fucntools模块里
             用的话要 先引入from functools import reduce
        求阶乘
                #编写一个文件(使用for循环)
                #!/usr/bin/python3
                # 通过用户输入数字计算阶乘
                # 获取用户输入的数字
                num = int(input("请输入一个数字: "))
                factorial = 1
                # 查看数字是负数，0 或 正数
                if num < 0:
                    print("抱歉，负数没有阶乘")
                elif num == 0:
                    print("0 的阶乘为 1")
                else:
                    for i in range(1,num + 1):
                        factorial = factorial*i
                    print("%d 的阶乘为 %d" %(num,factorial))



                >>> from functools import reduce
                >>> sum=reduce(lambda x,y:x*y,range(1,7))
                >>> print(sum)
                720

                >>> from functools import reduce
                >>> def myadd(x,y):
                    return x+y

                >>> sum=reduce(myadd,(1,2,3))
                >>> sum
                6

7.dict模拟实现switch的功能(函数调用)

switch-dict(字典实现switch的功能)
        -----switch语句：用于编写多个分支结构，但是python并没有switch语句
函数调用:
        通过字典调用函数
        {1:case1,2:case2}.get(x,lambda *args,**key:)()

        if-elif-elif形式的计算器

                from __future__ import division
                def add(x,y):
                    return x+y
                def sub(x,y):
                    return x-y
                def cheng(x,y):
                    return x*y
                def div(x,y):
                    return x/y
                def operator(x,o,y):
                    if o=='+':
                        print(add(x,y))
                    elif o=='-':
                        print(sub(x,y))
                    elif o=='*':
                        print(cheng(x,y))
                    elif o=='/':
                        print(div(x,y))
                    else:
                        pass
                operator(2,'+',4)
        字典调用的形式:
                    #字典中必须包含该值
                    from __future__ import division
                    def add(x,y):
                        return x+y
                    def sub(x,y):
                        return x-y
                    def cheng(x,y):
                        return x*y
                    def div(x,y):
                        return x/y 
                    operator={"+":add,"-":sub,"*":cheng,"/":div}
                    #print(operator["+"](3,2))#调用函数,通过函数与字典的调用,5
                    def f(x,o,y):
                        print(operator.get(o)(x,y))
                    f(3,"+",2)#5