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语句块

for it in [1,2,3,4]:
    print(it,end=",")
    if it == 4:
        break
else:
    print("执行else语句块")
#1,2,3,4,

 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的正式参数类型（必须参数、关键子参数、默认参数、可变长参数）

1. 必须参数：不需要提供的参数，否则会报错。
2. 关键子参数：既命名参数，直接通过参数名赋值，此时可以忽略参数提供的顺序。
3. 默认参数：当没有供参数时自动采用的值。
4. 可变长参数：*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))

python的return关键子

1. 如果没有使用return，则返回none，使用type()获取为：<class 'NoneType'>
2. 可以返回多个值，以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()

  由以上代码可以看出，局部作用域内的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

• 遍历技巧：

1. 对字典的遍历，使用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

2. 对序列遍历时，使用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

3. 同时对多个序列遍历时，使用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']

4. 反转序列，序列排序
   
   

• 模块
  　　__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	estWith.py") as withFd:
      pass
  print(withFd.closed)#True