011235813用java写出来_Python笔记4：控制流

if语句

虽然语法比较严格，但是语法糖也是较多的，比如我尝试用下面的if语句写了一个表达式，多样性的

if加不加括号都可以

elif是else if的缩写

最近一直在用kotlin，写的if..else..多了，就给黄色警告，提示可以切成switch，所以同理，下面的用法也可以替代switch

>>> x = int(input("enter num"))

enter num50

>>> if(x<0):

... x=0

... print("归零")

... elif x==0:

... print("0")

... elif(x==1):

... print("1")

... else:

... print("more")

...

more

for循环

Python中的for循环与C和java中的不太一样，格式和kotlin有点像，但也可以看出他的含义，注意语法就行了

# python普通for循环

>>> nums = ['one','two','three']

>>> for num in nums:

... print(num,len(num))

...

one 3

two 3

three 5

# kotlin和python的普通循环方式很像

val nums = arrayOf("one", "two", "three")

for (num in nums) {

println(num)

}

# 传统java的循环方式

String[] nums = new String[]{"one","two","three"};

for (String num : nums) {

System.out.println(num);

}

# python循环添加

>>> nums = ["one","two","three"]

>>> nums

['one', 'two', 'three']

# 循环中的切片副本必须显式调用

>>> for num in nums[:]:

... if len(num) >3:

... nums.insert(0,num)

...

>>> nums

['three', 'one', 'two', 'three']

range()函数

如果需要迭代遍历数字，那可以直接用内置函数range(),它会生成等差数列

# 类似传统的普通for循环

>>> for num in range(3):

... print(num)

...

0

1

2

# 范围循环

>>> for num in range(5,10):

... print(num)

...

5

6

7

8

9

# 间隔循环

>>> for num in range(0,10,3):

... print(num)

...

0

3

6

9

# 间隔负循环

>>> for num in range(0,-100,-25):

... print(num)

...

0

-25

-50

-75

# 遍历序列索引，合并range()和len()函数

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']

>>> for i in range(len(a)):

... print(i, a[i])

...

0 Mary

1 had

2 a

3 little

4 lamb

# 配合list

>>> list(range(5))

[0, 1, 2, 3, 4]

后面还有一些循环技巧，例如

>>> for i ,j in enumerate(["zhangsan","lisi","wangwu"]):

... print(i,j)

...

0 zhangsan

1 lisi

2 wangwu

控制流都这么多，这些技巧的到后面必须掌握一些

pass语句

一般程序执行的时候，什么都不做就什么都不用写，但是python不行，需要显式调用pass，表示忽略，或者可以理解为抽象方法，抽象类等等

调试的时候，不是经常这么干么？创建了一个函数，还来不及具体实现？就可以先用pass顶上

# 空循环

>>> while True:

... pass

...

# 空类

>>> class EmptyClass:

... pass

...

# 待定义函数

>>> def init(*args):

... pass

...

定义函数def

用关键词def修饰的方法称为定义函数，嗯，就是定义一个函数。

必须遵循函数名和正式参数的圆括号列表

函数主体从下一行开始

必须遵从缩进原则

函数可以通过赋值操作，并将值同时赋予

普通应用

# 定义一个斐波那契数列

>>> def fib(n):

... a,b = 0,1

... while a

... print(a,end=" ")

... a,b = b,a+b

... print()

...

# 测试结果

>>> fib(500)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

# 值传递

>>> fibonacci = fib

>>> fibonacci(500)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

# 打印出来的函数可以为None

# 先证明是有值的

>>> fib(20)

0 1 1 2 3 5 8 13

>>> fib(0)

>>> print(fib(0))

None

带返回值

上面的斐波那契数列虽然能打印出来，但其实是没有返回值的，以返回数组为例

>>> def fib(n):

... # 初始化一个空数组

... result = []

... a,b = 0,1

... while a

# append是追加到末尾的

# 等价于result = result + [a]

... result.append(a)

... a,b = b, a+b

... return result

...

>>> fib(100)

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

# 并且也可以赋值

>>> fib50 = fib(50)

>>> fib50

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

高级定义函数

参数默认值

顾名思义，就是给参数赋默认值,用Python自带的IDLE试试

默认值

只计算一次

只对定义范围内的函数定义处进行评估

in关键词可以检索序列中是否包含一定的值

# 定义函数，prompt必填,后两个选填

>>> def sayOk(prompt, retries = 4, reminder = "try again!"):

while True:

ok = input(prompt)

if ok in ("y", "ye", "yes"):

return True

if ok in ("n", "no","nop", "nope"):

return False

retries -= 1

if(retries) < 0:

raise ValueError("invalid user response")

print(reminder)

# 不填prompt会直接跳出

>>> sayOk()

Traceback (most recent call last):

File "", line 1, in

sayOk()

TypeError: sayOk() missing 1 required positional argument: 'prompt'

# 至少填一个，剩下为空会赋默认值

>>> sayOk("are you quit?")

are you quit?

try again!

are you quit?y

True

# 也可以都填

>>> sayOk("are you OK?",3,"say!you 倒是 say啊, 就say个yes或者no!")

are you OK?

say!you 倒是 say啊, 就say个yes或者no!

are you OK?no

False

参数累积

# 当默认值是可变参数时，会在后续调用中传递给它的参数累积

>>> def fun(a, List = []):

List.append(a)

return List

>>> print(fun(1))

[1]

>>> print(fun(2))

[1, 2]

>>> print(fun(3))

[1, 2, 3]

# 除非每次都置空

def fun(a, list=None):

if list is None:

list = []

list.append(a)

return list

print(fun(1))

print(fun(2))

print(fun(3))

[1]

[2]

[3]

关键字参数

关键词参数的好处在于，不需要按照定义的顺序去传参。

# 4个参数

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):

print("-- This parrot wouldn't", action, end=' ')

print("if you put", voltage, "volts through it.")

print("-- Lovely plumage, the", type)

print("-- It's", state, "!")

# 关键词参数，顺序不同，结果相同

parrot(voltage=1000000, action='VOOOOOM')

parrot(action='VOOOOOM', voltage=1000000)

# 没有关键词参数，会按照入参顺序排列

parrot('a million', 'bereft of life', 'jump')

无效的情况

parrot() # 没有请求参数

parrot(voltage=5.0, 'dead') # 关键字参数后面不能跟非关键字参数

parrot(110, voltage=220) # 会被判为相同参数，导致重复

parrot(actor='John Cleese') # 参数错误导致的未知参数

可变参数列表

一般的可变参数列表，不限数量，不限格式

>>> def concat(*args, sep="/"):

return sep.join(args)

>>> concat("one","two","three")

'one/two/three'

>>> concat("one","two","three",sep=" .")

'one .two .three'

复杂的例子

# *name必须在**name的前面

>>> def cheeseshop(kind, *args, **keywords):

print("--你这有",kind,"吗？")

print("--有，",kind,"是我们的招牌，咋能没有么！")

for arg in args:

print(arg)

print("-" * 40)

for key in keywords:

print(key,":",keywords[key])

# 输出

# 关键字参数的顺序和函数调用的顺序相同

>>> cheeseshop("肉夹馍","可好吃啦！全是肉","给我拿两个", laoban="陕西人", client="南方人")

# 结果

--你这有 肉夹馍 吗？

--有， 肉夹馍 是我们的招牌，咋能没有么！

可好吃啦！全是肉

给我拿两个

----------------------------------------

laoban : 陕西人

client : 南方人