目录
3,运算规则(b,a=a+1,b)跟(b=a+1;a=b;)是不一样的
(3)可更改(mutable)与不可更改(immutable)对象
(4)正式参数类型( 必需参数, 关键字参数, 默认参数, 不定长参数)
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。