标签：art   var   关系   改变   冒号   不可变对象   基础   效率   turn   

一.分支的基本语法

单if

if表达式：
    语句1
    语句2
    ……

2.条件表达式就是计算结果必须为布尔值得表达式
3.表达式后面的冒号不能少
4.注意if后面出现的语句，如果属于if语句块，则必须同一个缩进等级
5.条件表达式结果为True执行if后面的缩进语句块

双向分支

if表达式：
    语句1
    语句2
    ……
else：
    语句
    语句
    ……

缩进问题，if和else一个层次，其余语句一个层次。

多线路分支

    if 条件表达式:
        语句1：           
    elif 条件表达式:                    
     语句1           
    elif 条件表达式:                    
        语句1            
    else:                   
        语句1

注意：

1.if语句可以嵌套使用，但不推荐。
2.python没有switch-case语句。

二.循环语句

1.for循环
2.while循环

for循环

for 变量 in 列表：
    语句
    语句
    ……

eg:
~~~
for name in [‘abc‘,‘bcd‘,‘ddd‘]:
print(name)
~~~
输出:
abc
bcd
ddd
break,continue,pass
break与continue和C++中的没有区别
pass:表示略过，通常用于占位
eg:
~~~
for letter in ‘Python‘:
if letter == ‘h‘:
pass
print (‘这是 pass 块‘)
print (‘当前字母 :‘, letter)
~~~
输出：
当前字母 : P
当前字母 : y
当前字母 : t
这是 pass 块
当前字母 : h
当前字母 : o
当前字母 : n
注：
也可用于函数中的占位：
~~~
def sample(n_samples):
pass
~~~
该处的 pass 便是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。

while循环

语法：
~~~
while 条件表达式:
语句块
~~~
注：表达式两边不用加括号

三.函数

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
~~~
def 函数名（参数列表）:
函数体
~~~
默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
~~~
不可变类型：变量赋值 a=5 后再赋值 a=10，
这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，
不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4]
后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，
本身la没有动，只是其内部的一部分值被修改了。
~~~
python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。
           如fun（a），传递的只是a的值，没有影响a对象本身。
           比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 

eg:
~~~
def ChangeInt( a ):
a = 10

b = 2
ChangeInt(b)
print( b ) # 结果是 2

    可变类型：类似 c++ 的引用传递，如 列表，字典。
             如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
eg:

def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return

调用changeme函数

mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
~~~
传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
~~~
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]
~~~
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象

参数

以下是调用函数时可使用的正式参数类型：
必需参数
关键字参数
默认参数
不定长参数

必须参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：
~~~
def printme( str ):
"打印任何传入的字符串"
print (str)
return

调用 printme 函数，不加参数会报错

printme()
~~~
会输出：
~~~
Traceback (most recent call last):
File "test.py", line 10, in
printme()
TypeError: printme() missing 1 required positional argument: ‘str‘
~~~

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
~~~
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return

调用printinfo函数

printinfo( age=50, name="runoob" )

输出：
名字: runoob
年龄: 50
~~~

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
~~~
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return

调用printinfo函数

printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

输出：
名字: runoob
年龄: 50
------------------------
名字: runoob
年龄: 35
~~~

不定长参数

可看python基础教程（第三版）的p100和p66

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：
~~~
def functionname([formal_args,] var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
~~~
加了星号 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
~~~
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)

调用printinfo 函数

printinfo( 70, 60, 50 )
~~~
如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

还有一种就是参数带两个星号
基本语法如下：
~~~
def functionname([formal_args,] var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]
~~~
加了两个星号 的参数会以字典的形式导入。
~~~
def printinfo( arg1, vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)

调用printinfo 函数

printinfo(1, a=2,b=3)

输出:
1
{‘a‘: 2, ‘b‘: 3}
~~~
声明函数时，参数中星号 * 可以单独出现，例如:
~~~
def f(a,b,,c):
return a+b+c
~~~
如果单独出现星号 后的参数必须用关键字传入。
~~~

def f(a,b,*,c):
... return a+b+c
...
f(1,2,3) # 报错
Traceback (most recent call last):
File "", line 1, in
TypeError: f() takes 2 positional arguments but 3 were given
f(1,2,c=3) # 正常
6

~~~

匿名参数

（感觉和C的宏定义有点像）
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda 函数的语法只包含一个语句，如下：
~~~
lambda [arg1 [,arg2,.....argn]]:expression
~~~
~~~
sum = lambda arg1, arg2: arg1 + arg2

调用sum函数

print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

相加后的值为 : 30
相加后的值为 : 40
~~~

python

标签：art   var   关系   改变   冒号   不可变对象   基础   效率   turn   

原文地址：https://www.cnblogs.com/qianingmeng/p/11784725.html