python_ 学习笔记（hello world）

python中的循环语句

循环语句均可以尾随一个else语句块，该块再条件为false后执行一次

如果使用break跳出则不执行。

for it in [1,2,3,4]:

    print(it,end=",")

else:

    print("执行else语句块")

#1,2,3,4,执行else语句块

：不使用break

for it in [1,2,3,4]:

    print(it,end=",")

    if it == 4:

        break

else:

    print("执行else语句块")

#1,2,3,4,

：使用break

python的pass语句

pass语句只是为了保持程序的结构性，没有任何内容

python的函数参数

在函数的参数中，类似C++的值传递和引用传递，python中不可变元素在函数中修改不会影响外部的值（number、tuple、string），而可变元素则相反。

#传递可变参数

def mFcn(myDic):

    myDic['d'] = 2040

aDic = {'a':2010,'b':2020,'c':2030}

mFcn(aDic)

for it in aDic:

    print(it,aDic[it])

# a 2010

# b 2020

# c 2030

# d 2040

#传递不可变参数

def umFcn(myStr):

    myStr = "修改后"

aStr = '修改前'

umFcn(aStr)

print(aStr)#修改前

：测试传递可变或不可变参数的效果

python的正式参数类型（必须参数、关键子参数、默认参数、可变长参数）

必须参数：不需要提供的参数，否则会报错。
关键子参数：既命名参数，直接通过参数名赋值，此时可以忽略参数提供的顺序。
默认参数：当没有供参数时自动采用的值。

可变长参数：*t 相当于提供一个元组，**d 相当于提供一个字典。

def fcn4(*t):

    print(type(t))

    for it in t:

        print(it)

fcn4('a','v','d')

# <class 'tuple'>

# a

# v

# d

：不定长数组参数的传入方式

def fcn5(**d):

    print(type(d))

    for it in d:

        print(it , d[it])

fcn5(k1=1,k2='v2')

# <class 'dict'>

# k1 1

# k2 v2

：不定长字典参数的传入方式

参数传递中，* 可单独出现，强制其后的参数使用关键子参数的方式赋值

def testFcn(a,b,*,num1,num2):

    pass

#testFcn(1,2,3,4)#TypeError: testFcn() takes 2 positional arguments but 4 were given

testFcn(1,2,num1 = 3, num2 = 4)

：必须使用关键子参数赋值，否则报错

python匿名函数

python的lambda只是一个表达式，语法如下：

sum = lambda arg1,arg2:arg1+arg2

print(sum(10,90))

：lambda表达式例子

python的return关键子

如果没有使用return，则返回none，使用type()获取为：<class 'NoneType'>
可以返回多个值，以tuple方式返回

python的变量作用域

python的作用域有四种：按照查找顺序依次排列

局部作用域
嵌套作用域：闭包函数外的函数中
全局作用域
内置作用域：内置函数所在的模块范围

在python中，只有类（class）、模块（model）和函数（def lambda）会引入新的作用域

这也就是说，如果实在if语句、try-catch语句或者for/while语句中赋值定义的对象，和在其外部定义效果相同

为了区分不同作用域中的同名对象，可能需要使用关键子nonlocal和global

nonlocal：引入嵌套作用域的变量

global：引入全局作用域的变量
以nonlocal举例，global类似：

 #测试nonloacl和global关键子

 def fcn0():

     num = 0

     print('嵌套作用域头：' + str(num))

     #下面定义

     def fcn2():

         nonlocal num

         num = 1

         print('局部作用域：' + str(num))

     #下面调用

     fcn2()

     print('嵌套作用域尾：' + str(num))

 fcn0()

：nonlocal使用举例

由以上代码可以看出，局部作用域内的num其实是来自嵌套作用域，在局部的操作影响的嵌套作用域中的对象。

python3的数据结构

列表
列表可以用作堆栈和队列等，列表内置了基本的栈操作和队列操作
列表推导式：
一般用于对序列的每一个（或条件）元素都进行操作后，用这每一个新的结果生成一个新的列表
每个列表推导式都在for后跟一个表达式，然后有零到多个for或if子句。推导元组必须使用括号
```
#测试列表推导式

l1 = [-0.5,-0.33,-0.1,0,1,33,5.55]

#全部遍历

li2 = [it*2 for it in l1]

print(li2)

#[-1.0, -0.66, -0.2, 0, 2, 66, 11.1]
```
：遍历所有元素
```
#测试列表推导式

l1 = [-0.5,-0.33,-0.1,0,1,33,5.55]

#条件遍历：只遍历符合条件的元素

li2 = [it*2 for it in l1 if it >= 0]

print(li2)#[0, 2, 66, 11.1]
```
：遍历符合条件的元素
del语句
del可以使用下表来删除元素，也可以用来删除实体变量
元组和序列
元组：元组由多个值组成 a = 123,456,'nihao'
序列。。。
集合:
集合内部元素不重复，集合内部元素无序，集合也可以使用推导式

字典：
字典创建键值对推导式

d = {k:k**2 for k in (1,2,3,4,5,6)}

for k,v in d.items():

    print(k,v)

# 1 1

# 2 4

# 3 9

# 4 16

# 5 25

# 6 36

：字典推导式

遍历技巧：

对字典的遍历，使用items()同时获取键和值；

d = {k:k**2 for k in (1,2,3,4,5,6)}

for k,v in d.items():

    print(k,v)

# 1 1

# 2 4

# 3 9

# 4 16

# 5 25

# 6 36

：遍历字典技巧

对序列遍历时，使用enumrate()同时获取下标和元素；

t = [x*2 for x in range(5)]

for index,item in enumerate(t, 0):

    print(index,item)

# 0 0

# 1 2

# 2 4

# 3 6

# 4 8

：遍历序列的技巧

同时对多个序列遍历时，使用zip(t1,t2)组合

t1 = ['name:','age:','id:']

t2 = ['lyn', 23, 20130430721]

msg = [str(t) + str(c) for t,c in zip(t1,t2)]

print(msg)

#['name:lyn', 'age:23', 'id:20130430721']

：遍历多个序列技巧

反转序列，序列排序

模块
　　__Name__ 属性，当模块是自身在运行是__name__属性为“__main__”，如果不是自生在运行，而是被其他模块导入，则__name__属性是当前模块的名称！
异常处理try...excepte ex1...except ex2...except ...else...finally
尝试执行try块中的代码，如果发生异常则逐个匹配except的异常类型，如果匹配到则执行并执行异常处理之后的代码。
- except后不跟任何异常类型则匹配所有的异常，你可以在这里输出异常，并再次抛出给上层代码。
- else块在没有发生异常时执行。
- finally，无论如何都会执行，finally会再次抛出这个异常
抛出异常
使用raise语句抛出一个异常，raise NameError("这是一个异常")，raise后面的必须是异常的实力或者异常的类（也就是exception的子类）;
如果我们只想检测是否有异常，而不是处理它，那么我们可以直接使用raise不跟任何语句，就可以再次抛出这个异常；
通过继承Exception类，我们可以定义自己的异常类，名称一般以Error结尾，这和标准的异常命名一样！
with语句，类似于C#using对于非托管资源的处理
无论发生什么，这个资源都会被正确的执行清理方法
```
with open(r"G:\PythonWorkSpace\testWith.py") as withFd:

    pass

print(withFd.closed)#True
```
：with关键字的用法