06 python控制语句和其他语句
1、基本语句
1.1、input获取用户输入
- varname=input(“提示信息”)
- input默认输入的值都是字符串。
- type()查看数据类型。
- int()强制转换为整型。
- python2中的raw_input和python3中的input相同（python2中input不建议使用）。
name=input("名字:")
age=int(input("年龄:"))
print("名字:{}，data_type_name:{}".format(name,type(name)))
print("年龄:{}，data_type_age:{}".format(age,type(age)))
>>>
名字:hh
年龄:22
<<
名字:hh，data_type_name:<class 'str'>
年龄:22，data_type_age:<class 'int'>
- input的输入流使字符串不适用intern机制，小整数对象池在pycharm中却适用了。
a1 = int(input('请输入整数256给a1：')) #pycharm中运行
a2 = int(input('请输入整数256给a2：'))
b1 = int(input('请输入整数257给b1：'))
b2 = int(input('请输入整数257给b2：'))
c1 = input('请输入字符串"aaa"给c1：')
c2 = input('请输入字符串"aaa"给c2：')
d1 = 'aaa'
d2 = 'aaa'
print('a1 = {}, a1_id：{}'.format(a1,id(a1)))
print('a2 = {}, a2_id：{}, a1 is a2：{}'.format(a2,id(a2),a1 is a2)) #a1 is a2：True
print('b1 = {}, b1_id：{}'.format(b1,id(b1)))
print('b2 = {}, b2_id：{}, b1 is b2：{}'.format(b2,id(b2),b1 is b2)) #1 is b2：False
print('c1 = {}, c1_id：{}'.format(c1,id(c1)))
print('c2 = {}, c2_id：{}, c1 is c2：{}'.format(c2,id(c2),c1 is c2)) #c1 is c2：False，特别注意
print('d1 = {}, d1_id：{}'.format(d1,id(d1)))
print('d2 = {}, d2_id：{}, d1 is d2：{}'.format(d2,id(d2),d1 is d2)) #d1 is d2：True
1.2、print语句
- print可用于打印一个表达式，这个表达式要么是字符串，要么将自动转换为字符串。
- 可以同时打印多个表达式，条件是用逗号分隔它们，该逗号默认转化为空格。
- 使用连字符“+”，表达式之间不会有空格。
>>> print('Age:', 42)
Age: 42
>>> print('Hello,', 'Mr.', 'Gumby')
Hello, Mr. Gumby
>>> print('Hello', ',', 'Mr.', 'Gumby') #输出时逗号前有个空格
Hello , Mr. Gumby
>>> print('Hello' + ',', 'Mr.', 'Gumby') #输出时逗号前无空格
Hello, Mr. Gumby
1、print帮助
>>> help(print)
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file：一个文件类对象(流);默认为当前sys.stdout
sep：插入value之间的字符串(即输出分隔符)，默认为空格。
end：在最后一个值之后追加的字符串，默认为换行符。
flush：是否强制冲洗流。
2、可自定义分隔符：
>>> print("I", "wish", "to", "register", "a", "complaint")
I wish to register a complaint
>>> print("I", "wish", "to", "register", "a", "complaint", sep="_")
I_wish_to_register_a_complaint
3、自定义结束字符串，以替换默认的换行符。
print('Hello,', end='')
print('world!')
>>>
Hello,world!
4、格式化输出
name = 'maiheng'
age = 22
height = 170
print('我的名字叫' + name + ',我今年' + str(age) + '岁,身高' + str(height) + 'cm。' )
print('我的名字叫%s，我今年%s，身高%scm。' %(name,age,height))
print('我的名字叫%s，我今年%4d，身高%.2fcm。' %(name,age,height))
print('我的名字叫{}，我今年{}，身高{}cm。'.format(name,age,height))
print('我的名字叫{h1}，我今年{h2:.2f}，身高{h3:5d}cm。'.format(h2=age,h1=name,h3=height))
<<<
我的名字叫maiheng，我今年22，身高170cm。
我的名字叫maiheng，我今年 22，身高170.00cm。
我的名字叫maiheng，我今年22，身高170cm。
我的名字叫maiheng，我今年22.00，身高 170cm。
1.3、import语句(模块)
- Python的强大之处在于他有非常丰富和强大的标准库和第三方库,几乎你想实现的任何功能都有相应的Python库支持。
1、调用模块
- 从模块导入时，通常使用
import somemodule [as 别名]
from somemodule import somefunction [as 别名]
from somemodule import somefunction, anotherfunction, yetanotherfunctio
from somemodule import *
- 如果有两个模块，它们都包含函数open，可以使用第一种方式导入这两个模块。
import module1
import module2
像下面这样调用函数：
module1.open(...)
module2.open(...)
也可以在语句末尾添加as子句并指定别名。
from module1 import open as open1
from module2 import open as open2
像下面这样调用函数：
open1(...)
open2(...)
- 有些模块（如os.path）组成了层次结构（一个模块位于另一个模块中）
2、使用模块
- sys模块
sys.path：打印python全局环境变量
sys.argv：返回一个列表，[‘程序文件名称’,参数1,参数2,…,参数n]
sys.argv[n]：返回列表的第n个参数
import sys print(sys.argv) d:\>python D:/test/python/day1/hh.py 1 2 3 #绝对路径 ['D:/test/python/day1/hh.py', '1', '2', '3'] D:\test\python\day1>python hh.py 1 2 3 #相对路径 ['hh.py', '1', '2', '3'] import sys print(sys.argv[2]) #返回第二个参数 D:\test\python\day1>python hh.py 1 2 3 2
- os模块
os.system(”系统命令”)：直接输出命令结果，不保存结果。
os.popen(”系统命令”)：将命令结果保存到内存，返回该内存地址
os.popen(”系统命令”).read()：读取内存中的内容，并返回内存中的内容
os.mkdir(“目录名”)：创建一个目录，返回NONE
import os
os.system("dir")
os.mkdir("new_hh")
print('---------------------------------')
print(os.popen("dir"))
print('---------------------------------')
print(os.popen("dir").read())
- getpass模块
getpass.getpass(“提示信息”)：隐式输入密码
import getpass
hh = getpass.getpass("请输入hengha：")
if hh=="hengha":
print("输入的是：",hh)
else:
print("输入的不是hengha")
D:\test\python\day1>python hh.py #在pycharm中执行有问题
请输入hengha：
输入的是： hengha
1.4、赋值语句
1、序列解包
- 序列解包（或可迭代对象解包）：将一个序列（或任何可迭代对象）解包，并将得到的值存储到一系列变量中。
(1)同时（并行）给多个变量赋值：
- 要解包的序列包含的元素个数必须与等号左边列出的变量个数相等，否则Python将引发异常。
>>> x, y, z = 1, 2, 3
>>> print(x, y, z)
1 2 3
>>> a=(4,5,6)
>>> x,y,z=a
>>> print(x, y, z)
4 5 6
>>> scoundrel = {'name': 'Robin', 'girlfriend': 'Marion'}
>>> key, value = scoundrel.popitem()
>>> print('key={},value={}'.format(key,value))
key=girlfriend,value=Marion
(2)星号运算符（*）
- 可使用星号运算符（*）来收集多余的序列元素，这样就无需确保序列元素和变量的个数相同。星号*可以在任意位置。
- 赋值语句的右边可以是任何类型的序列，但带星号的变量最终包含的总是一个列表。在变量和值的个数相同时亦如此。
###序列解包
>>> a, b, *rest = [1, 2, 3, 4]
>>> rest
[3, 4]
>>> a, *b, c = "abc"
>>> a, b, c
('a', ['b'], 'c')
###手动解包（加星号）
>>> a = [1, 2, 3]
>>> print(a)
[1, 2, 3]
>>> print(*a)
1 2 3
>>> a = (1, 2, 3)
>>> print(a)
(1, 2, 3)
>>> print(*a)
1 2 3
>>> a = 'mai'
>>> print(a)
mai
>>> print(*a)
m a i
2、链式赋值
- 链式赋值是一种快捷方式，用于将多个变量关联到同一个值。类似并行赋值，但只涉及一个值。
x = y = somefunction()
等价：
y = somefunction()
x = y
请注意，可能与下面的语句不等价：
x = somefunction()
y = somefunction()
3、增强赋值
- x = x + 1写成x += 1。这称为增强赋值，适用于所有标准运算符，如*、/、%等
>>> x = 2 >>> x += 1 >>> x *= 2 >>> x 6 >>> fnord = 'foo' >>> fnord += 'bar' >>> fnord *= 2 >>> fnord 'foobarfoobar'
2、代码块：缩进
- 代码块其实并不是一种语句。
- 代码块是一组语句，可在满足条件时执行（if语句），可执行多次（循环），等等。
- 代码块是通过缩进代码（即在前面加空格）来创建的。
- 也可以使用制表符来缩进代码块。但标准（也是更佳的）做法是只使用空格（而不使用制表符）来缩进，且每级缩进4个空格。
- 在Python中，使用冒号（:）指出接下来是一个代码块，并将该代码块中的每行代码的缩进量必须相同。
3、if 语句
3.1、基本 if 语句
1、单分支if语句
if 条件: 语句
import random random_num = random.randint(1,10) num = int(input('请您输入您猜的数字（1-10）：')) if random_num == num : print('恭喜您，您猜对了，它就是%d' % random_num) print('它是%d，你猜对了吗？' % random_num)
2、双分支if语句
if 条件: 语句 else: 语句
import random random_num = random.randint(1,10) num = int(input('请您输入您猜的数字（1-10）：')) if num == random_num: print('恭喜您，您猜对了，它就是{}'.format(random_num)) else: print('很抱歉，您猜错了，它是{}'.format(random_num))
3、多分支if语句
if 条件: 语句 elif 条件: 语句 ... elif 条件: 语句 else: 语句
import random random_num = random.randint(1,10) num = int(input('请您输入您猜的数字（1-10）：')) if num == random_num: print('恭喜您，您猜对了，它就是{}'.format(random_num)) elif num > random_num: print('很抱歉，您猜大了，它是{}'.format(random_num)) else: print('很抱歉，您猜小了，它是{}'.format(random_num))
3.2、断言
- 在语句中使用关键字assert。
- 还可在条件后面添加一个字符串，对断言做出说明。
assert 条件
assert 条件, "显示信息"
>>> age = 10
>>> assert 0 < age < 100 #满足条件时，正常执行，无异常
>>> age = -1
>>> assert 0 < age < 100 #不满足条件时，返回异常
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
assert 0 < age < 100
AssertionError
>>> age = -1
>>> assert 0 < age < 100, 'The age must be realistic' #条件不满足时，返回异常及指定说明信息
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
assert 0 < age < 100, 'The age must be realistic'
AssertionError: The age must be realistic
4、循环
- 只要能够使用for循环，就不要使用while循环。
4.1、while 循环
while 条件: 语句
x = 1
while x <= 100:
print(x)
x += 1
name = ''
while not name:
name = input('Please enter your name: ')
print('Hello, {}!'.format(name))
i=1 while i <= 9: j = 1 while j <= i: print("{}*{}={}".format(j,i,i*j),end="\t") j += 1 print() i += 1
import random random_num = random.randint(1, 10) print('猜一个1到10随机数字，您可以猜三次。') i = 0 while i < 3: num = int(input('请你输入您猜的数字：')) if num == random_num: print('恭喜您，您猜对了，它就是{}'.format(random_num)) break elif num > random_num and i != 2: print('很抱歉，您猜大了，请再猜一次。') elif num < random_num and i != 2: print('很抱歉，您猜小了，请再猜一次。') else: print('很抱歉，您猜错了，它是%d' % random_num) i += 1
4.2、for 循环
- 基本上，可迭代对象是可使用for循环进行遍历的对象。
for i in 可迭代对象:
语句
1、内置函数range(起始数,结束数,步长)：
for number in range(1,100,2): #步长是整数 print(number) for number in range(100,0,-2): #步长是负数，注意起始数和结束数的大小 print(number)
2、遍历序列：
words = ['this', 'is', 'an', 'ex', 'parrot'] for word in words: print(word) numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] for number in numbers: print(number)
3、遍历字典
d = {'x': 1, 'y': 2, 'z': 3}
for key in d:
print(key, 'corresponds to', d[key])
d = {'x': 111, 'y': 222, 'z': 333}
for key, value in d.items():
print(key, 'corresponds to', value)
4、并行迭代
- 内置函数zip，它将两个序列“缝合”起来，并返回一个由元组组成的序列。返回值是一个适合迭代的对象，要查看其内容，可使用list将其转换为列表。
- 函数zip可用于“缝合”任意数量的序列。需要指出的是，当序列的长度不同时，函数zip将在最短的序列用完后停止“缝合”。
names = ['anne', 'beth', 'george', 'damon'] ages = [12, 45, 32, 102] for i in range(len(names)): print(names[i], 'is', ages[i], 'years old') for name, age in zip(names, ages): print(name, 'is', age, 'years old') >>> list(zip(range(5), range(100000000))) [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
for i in range(1,10): for j in range(1,i): print("{}*{}={}".format(j, i, i * j), end="\t") print()
import random random_num = random.randint(1, 10) print('猜一个1到10随机数字，您可以猜三次。') for i in range(3): num = int(input('请你输入您猜的数字：')) if num == random_num: print('恭喜您，您猜对了，它就是{}'.format(random_num)) break elif num > random_num and i != 2: print('很抱歉，您猜大了，请再猜一次。') elif num < random_num and i != 2: print('很抱歉，您猜小了，请再猜一次。') else: print('很抱歉，您猜错了，它是%d' % random_num)
4.3、break和continue
1、break
- break结束（跳出）循环
- 在多层循环中，结束所在的循环
from math import sqrt for n in range(1,5): print(n) if n>=3: break
2、continue
- 语句continue没有break用得多。它结束当前迭代，并跳到下一次迭代开头。
from math import sqrt for n in range(1,5): if n%2 == 0: continue print(n)
3、while True/break示例
while True:
word = input('Please enter a word: ')
if not word: break
print('The word was ', word)
4.4、循环中的else 子句
- 在循环中添加一条else子句，它仅在没有调用break时才执行。即break跳出本层循环，包括本层循环的else。
from math import sqrt
for n in range(1,5):
print(n)
if n>=6:
break
else:
print('没有执行break') #被执行
i = 1
while i <= 5:
print(i)
if i >= 6:
break
i += 1
else:
print('没有执行break') #被执行
4.4、简单推导
- 在简单推导中写在前面的控制语句是外层的，写在后面的控制语句是内层的。即每加一个控制语句就多加了一层。
girls = ['alice', 'bernice', 'clarice']
boys = ['chris', 'arnold', 'bob']
[b+'+'+g for b in boys for g in girls if b[0] == g[0]]
相当于
result = []
for b in boys:
for g in girls:
if b[0] == g[0]:
result.append(b + '+' + g)
print(result) #结果是：['chris+clarice', 'arnold+alice', 'bob+bernice']
1、列表推导
- 列表推导是一种从其他列表创建列表的方式，使用方括号。
###无if语句的列表推导 >>> [x * x for x in range(10)] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> [(x, y) for x in range(3) for y in range(3)] [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)] ###有if语句的列表推导 >>> [x for x in range(100) if x % 3 == 0 and x % 5 == 0] #可以被3和5整除 [0, 15, 30, 45, 60, 75, 90] >>> girls = ['alice', 'bernice', 'clarice'] >>> boys = ['chris', 'arnold', 'bob'] >>> [b+'+'+g for b in boys for g in girls if b[0] == g[0]] ['chris+clarice', 'arnold+alice', 'bob+bernice'] ###有if/else语句的列表推导 >>> [x - 1 if x < 5 else x + 1 for x in range(10)] #小于5的减1，大于5的加1。 #for前面的是一个整体，如果x<5执行x-1，否则执行x+1 [-1, 0, 1, 2, 3, 6, 7, 8, 9, 10]
2、字典推导
- 使用花括号实现字典推导。
>>> squares = {i:"{}".format(i**2) for i in range(6)}
>>> squares
{0: '0', 1: '1', 2: '4', 3: '9', 4: '16', 5: '25'}
3、集合推导
- 使用花括号实现集合推导
>>> list1 = [1, 9, 2, 3, 1, 4, 5, 3]
>>> set1 = {x for x in list1}
>>> set1
{1, 2, 3, 4, 5, 9}
4、生成器
- 使用圆括号代替方括号并不能实现元组推导，而是创建生成器
5、pass、del、exec和eval
5.1、pass
- 在Python中代码块不能为空。
- pass语句什么都不做，但适合用作占位符。
if name == 'Ralph Auldus Melish':
print('Welcome!')
elif name == 'Enid':
# 还未完成……
pass
elif name == 'Bill Gates':
print('Access Denied')
5.2、del
- del语句不仅会删除对象的引用，还会删除名称本身，但不能用于删除值。
- 事实上，在Python中，根本就没有办法删除值。不再使用的值，Python解释器会立即将其删除。
5.3、exec和eval
1、exec
- 函数exec用于将字符串作为Python程序执行。
- 函数exec主要用于动态地创建代码字符串。
>>> a="print('Hello, world!')"
>>> exec(a)
Hello, world!
- 添加第二个参数——字典，用作代码字符串的命名空间。
- 实际上，可向exec提供两个命名空间：一个全局的和一个局部的。提供的全局命名空间必须是字典，而提供的局部命名空间可以是任何映射。这一点也适用于eval。
>>> from math import sqrt
>>> exec("sqrt = 1")
>>> sqrt
1
>>> sqrt(4)
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
sqrt(4)
TypeError: 'int' object is not callable
>>> from math import sqrt
>>> scope = {}
>>> exec('sqrt = 1', scope)
>>> sqrt(4)
2.0
>>> scope['sqrt']
1
>>> len(scope)
2
>>> scope.keys()
dict_keys(['__builtins__', 'sqrt'])
2、eval
- 函数eval计算用字符串表示的表达式并返回结果（exec什么都不返回，因为它本身是条语句）
>>> eval(input("Enter an arithmetic expression: "))
Enter an arithmetic expression: 3+4*7
31
6、练习
1、输出1-100之间的偶数之和
#示例1： i = 0 sum = 0 while i <= 100: if i % 2 ==0: sum += i i += 1 print('1-100之间的偶数之和是：',sum) #示例2： i = 0 sum = 0 while i <= 100: i += 1 #continue会提前结束本次迭代，因此自加必须放在前面 if i % 2 != 0: continue sum += i print('1-100之间的偶数之和是：',sum) #示例3： for i in range(1,101): if i % 2 == 0: sum += i print('1-100之间的偶数之和是：', sum) #示例4 sum = 0 for i in range(1,101): if i % 2 != 0: continue sum += i print('1-100之间的偶数之和是：', sum)
