python3--学习笔记，准备开始编程

 

目录

1，不同数值类型的 true 和 false

2，end 关键字

3，运算规则(b,a=a+1,b)跟（b=a+1;a=b;）是不一样的

5,容器总结

6,Python3 循环语句

7,pass 语句

8,迭代器

StopIteration

9，生成器

10,函数

     （1）基本用法

（2）参数 传递

（3）可更改(mutable)与不可更改(immutable)对象

python 传不可变对象实例

传可变对象实例

（4）正式参数类型( 必需参数,   关键字参数,    默认参数,   不定长参数)

（5）匿名函数

（6）变量作用域

---

1，不同数值类型的 true 和 false

类型	False	True
布尔	False(与0等价)	True(与1等价)
数值	0,   0.0	非零的数值
字符串	'',  ""(空字符串)	非空字符串
容器	[],  (),  {},  set()	至少有一个元素的容器对象
None	None	非None对象

2，end 关键字

  关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

a, b = 0, 0;
while b < 3:
    b=a+1;
    a=b;
    print(b,end=",");
    print()
    print(b, end=" ");
console:
1,
1 2,
2 3,
3 

3，运算规则(b,a=a+1,b)跟（b=a+1;a=b;）是不一样的

a,b=0,0;#先计算，再赋值
while b < 3:
    b,a=a+1,b;  print(b,end=","); print(a,end="   ");
print();
a,b=0,0;
while b < 3:
    n = b;
    b = a + 1;
    a = n;  print(b,end=","); print(a,end="   ");
print();
a, b = 0, 0;
while b < 3:
    b=a+1;
    a=b;  print(b,end=","); print(a,end="   ");

console:
1,0   1,1   2,1   2,2   3,2   
1,0   1,1   2,1   2,2   3,2   
1,1   2,2   3,3  

4，if 语句

if True:
    print(1);
else:
    print(2);
console:
1
#求几率
import random
a,i,q,w,e,r,t=True,0,0,0,0,100,100;
while a:
 x = random.choice(range(100));  # 0-99的随机数
 y = random.choice(range(200))  # 0-199的随机数
 i=i+1;
 if i==t:a=False;
 if   x == y:
    q=q+1;
 elif x > y:
    w=w+1;
 else :
    e=e+1;
console:
x等于y的几率： 0.0  x大于y的几率： 0.21  x小于y的几率： 0.79

5,容器总结

1. 有序：list，tuple，str和unicode；
2. 无序：set
3. 无序并且具有 key-value 对：dict    
4,都是可以通过 for--in--进行遍历的 ，

6,Python3 循环语句

Python中的循环语句有 for 和 while。

while w:
    print("这是一个While循环");
    i=i+1;
    if i>10:w=False;
else:
   print("退出")

for x in "123":
    print(x);
else:
    print("退出")

range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
 for i in range(len(a)):
     print(i, a[i])

break和continue语句及循环中的else子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行

7,pass 语句

Python pass是空语句，是为了保持程序结构的完整性。
            pass 不做任何事情，一般用做占位语句

if 2>1:
    pass  
class MyEmptyClass:
    pass
while True:
    pass  
#pass 代表函数不执行其他操作 或者 类没有其他成员变量或函数 
#这里如果不做任何处理，直接跳过，但是如果不写pass，就会语法错误
但是可以跟执行语句
if 2>1:
    pass  
    print(1)
class MyEmptyClass:
    pass
    print(2)

for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)
 
print ("Good bye!")
console:
1
2
当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

8,迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
print (next(it),next(it),next(it),next(it))   # 输出迭代器的下一个元素
for x in iter(list):
    print (x, end=" ");
print ();
import sys  # 引入 sys 模块
it = iter(list)
while True:
   try:
       print(next(it));
   except StopIteration:
       sys.exit()

console:
1 2 3 4
1 2 3 4 
1
2
3
4

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self
    def __next__(self):
        if self.a <= 2:
            x = self.a
            self.a += 1
            return x
         else:
             raise StopIteration

不加StopIteration 会报错，不加else 会一直循环输出None
myclass = MyNumbers();
myiter = iter(myclass);
for x in myiter:
   print(x)

9，生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
以下实例使用 yield 实现斐波那契数列：

import sys
def fibonacci(n):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(5)  # f 是一个迭代器，由生成器返回生成
while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()
console:
0 1 1 2 3 5 

10,函数

     （1）基本用法

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

def hello() :
   print("Hello World!")
print(hello());
def hello1():
    return "Hello World1!";
print(hello1());
console:
Hello World!
None
Hello World1!

写一个计算器

def calculator(num1,num2,sign):
  ret,str=None,"";
  try:
        if (sign == "+"):
            ret = num1 + num2;
        elif (sign == "-"):
            ret = num1 - num2;
        elif (sign == "*"):
            ret = num1 * num2;
        elif (sign == "/"):
            ret = num1 / num2;
        str=num1+sign+num2;
  except Exception  as e:
        str="出错了"+e;
  finally:
      print(retStr+" = ",end="  ");
      return ret;
print(calculator(1,0,"/"))
print(calculator(1,1,"/"))
console:
division by zero
 =   None
1  /  1 =   1.0

（2）参数 传递

在 python 中，类型属于对象，变量是没有类型的。a仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

def test(a):
 print(a,type(a))
print(test(1),test('1'),test(True),test(4.1),test({1,2,3}),test((1,2,3)),test({1:2}),test([1,3,4]));
console:
1 <class 'int'>
1 <class 'str'>
True <class 'bool'>
4.1 <class 'float'>
{1, 2, 3} <class 'set'>
(1, 2, 3) <class 'tuple'>
{1: 2} <class 'dict'>
[1, 3, 4] <class 'list'>
None None None None None None None None

（3）可更改(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 本身。
    可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

def ChangeInt( a ):
    a = 10
b = 2
ChangeInt(b)
print( b ) # 结果是 2

传可变对象实例

def changeme(mylist):
    "修改传入的列表"
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return
# 调用changeme函数
mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: ", mylist)
console:
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

（4）正式参数类型( 必需参数,   关键字参数,    默认参数,   不定长参数)

必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误

# 可写函数说明
def printme( ab):
    print(ab);#"打印任何传入的字符串"
    return
# 调用printme函数
printme(1)

关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：

def printme(str1,str2):
    print(str1+" "+str2)
    return

# 调用printme函数
printme(str2="OKOK",str1="今天天气不错")
console:
今天天气不错 OKOK

默认参数 
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

def day(a=1,b=3):
  print("a=",a," b=",b);
day(b=1)
day(1)
console:
a= 1  b= 1
a= 1  b= 3

不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
加了两个星号 ** 的参数会以字典的形式导入。

def printinfo(arg1, *vartuple):
    print("输出: ",arg1,vartuple)
printinfo(70, 60, 50);printinfo(80)

def printinfo2(arg1, **vartuple):
    print("输出2: ",arg1,vartuple)
printinfo2(70, a=60, b=50);printinfo2(80)
console:
输出:  70 (60, 50)
输出:  80 ()
输出2:  70 {'a': 60, 'b': 50}
输出2:  80 {}

如果单独出现星号 * 后的参数必须用关键字传入。

def f(a,b,*,c):
  return a+b+c
# print(f(1,2,3))#TypeError: f() takes 2 positional arguments but 3 were given
print(f(1,2,c=3))#6

（5）匿名函数

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

sum = lambda arg1, arg2: arg1 + arg2
minus = lambda arg1, arg2: arg1 - arg2
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相减后的值为 : ", minus( 20, 30 ))
console:
相加后的值为 :  30
相减后的值为 :  -10

（6）变量作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
    L （Local） 局部作用域
    E （Enclosing） 闭包函数外的函数中
    G （Global） 全局作用域
    B （Built-in） 内建作用域
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

x = int(2.9)         # 内建作用域          B
g_count = 0          # 全局作用域          G
def outer():
    o_count = 1      # 闭包函数外的函数中   E
    def inner():
        i_count = 2  # 局部作用域          L

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，
其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问

if True:
    msg="123"
print(msg)#123
def a():
    msg1="4565";
print(msg1)#NameError: name 'msg1' is not defined

全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

total = 0  # 这是一个全局变量
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2  # total在这里是局部变量.
    print("函数内是局部变量 : ", total)
    return total
sum(10, 20)
print("函数外是全局变量 : ", total)
console:
函数内是局部变量 :  30
函数外是全局变量 :  0

global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
以下实例修改全局变量 num：

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)
console:
1
123
123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

def outer():
    num = 10
    def inner():
       # print(num)#SyntaxError: name 'num' is used prior to nonlocal declaration
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()
console:
100
100

 

 

 

11，异常

try:
    需要执行的操作
except 异常类 as e:
    如果发生异常，执行以下代码
else:
    如果没有发生异常，执行的命令
finally:
    无论如何，都要执行的代码

常见的异常类型：
1. ImportError: 输入错误。
2. IndexError: 索引超出列表范围。
3. NameError: 尝试访问一个没有申明的变量。
4.SyntaxError: 语法错误。
5.TypeError: 传给函数的参数类型不正确。
6.ValueError: 传给函数的参数类型正确，但是值不正确。
7.KeyError: 请求一个不存在的字典关键字。
8.ZeroDivisionError: 除数为0。