Python基本操作2

Python操作2 ------语句和表达式

1、Python代码风格

python代码风格：pep8、缩进4空格、一行不超过79个字符、两个函数之间空两行。

2、Python语句

赋值语句

简单的赋值语句：
简单变量赋值：

>>> a =3
>>> b =5
>>> a 
3
>>> b
5
>>>

元组赋值：

#元组的赋值
>>> (x,y) = (3,5)
>>> (x,y)
(3, 5)
#元组的赋值可以省略括号
>>> x,y = 3,5
>>> x,y
(3, 5)

列表的赋值：

>>> [x,y,z] = [10,20,30]
>>> [x,y,z]
[10, 20, 30]

此外Python可以很方便的交换两个变量的值

>>> x = 20
>>> y = 50
>>> x,y = y,x
>>> x
50
>>> y
20

多目标赋值

#一个字符串赋值给同样长度的变量，是按位赋值，如下：
>>> a,b,c = 'bye'
>>> a 
'b'
>>> b
'y'
>>> c 
'e'

如果字符串的长度大于变量的个数可以采取以下方式赋值：

#方法一
>>> s = 'helloworld'
>>> a = s[0]
>>> b = s[1]
>>> c = s[2:]
>>> a 
'h'
>>> b 
'e'
>>> c 
'lloworld'


#方法二
>>> a , b, *c = 'hellworld'  # *变量名是将剩余对像以列表的形式赋值给该变量
>>> a 
'h'
>>> b
'e'
>>> c 
['l', 'l', 'w', 'o', 'r', 'l', 'd']

#同样的也可以将剩余变量赋值给b
>>> a,*b,c = 'helloworld'
>>>> a
'h'
>>> b 
['e', 'l', 'l', 'o', 'w', 'o', 'r', 'l']
>>> b = ''.join(b)  # 将列表变量转换成字符串变量
>>> b 
'elloworl'
>>> c 
'd'
#如果变量个数多于字符串长度，则将最后变量赋值为空列表
>>> a,b,c,*d = 'bye'
>>> a 
'b'
>>> b 
'y'
>>> c 
'e'
>>> d 
[]

判断两个变量的值和内存地址是否相同

#判断值是否相同
>>> a = 'hello'
>>> b = 'hello'
>>> a == b 
True
#判断a,b的指向的内存地址是否相同
>>> a is b 
True


#如果对象简单，则Python一开始就定义了，所以两个不同的变量指向的内存地址相同
#如果对象复杂，两个不同的变量指向的内存地址则不同
>>> a = 'helloworld.com'
>>> b = 'helloworld.com'
>>> a == b #判断值是否相同
True
>>> a is b #判断变量指向的内存地址是否相同
False

参数化赋值

>>> a = 5
>>> b = 10 
>>> b += a 
>>> b 
15

#列表  相当于列表的扩展
>>> l = [1,2]
>>> l += [9,0]
>>> l
[1, 2, 9, 0]

#用extend()函数实现列表的扩展
>>> l.extend([2,3,4])
>>> l 
[1, 2, 9, 0, 2, 3, 4]
>>> 

2、表达式

Python表达式分为：
1、函数的调用。如：len()函数的使用
2、方法的使用。如：l.append()方法的使用
3、字面值
4、打印操作 print（参数1，参数2，参数…，sep = ’ ',end = ’ ',file = open(‘文件路径.文件名称’，‘操作’，encoding = ’ ')）
(sep为分割符，end为结束符，file为输出到文件，encoding 是编码方式)

流程控制

if条件句

一般格式如下：

#if 语句的一般格式
score = 75
if score>= 60:
    print('及格')
else:
    print('不及格')

及格

多条件句：

#多条件句
score = 86
if score >=90:
    print('优秀')
elif score>= 80:
    print('良好')
elif score >=60:
    print('及格')
else:
    print('不及格')

良好

多重分支

#多重分支  类似于其他编程语言的 case
operation = {'add':'添加操作','update':'更新','del':'删除操作' }
print(operation.get('del'))
删除操作



#Python中用字典表的方式弥补了其在多重分支语句上的不足，
#同时字典表中也可以用函数来表示键的值，例如：

#定义加法函数
def add(x):
    print(x+10)
    
#定义字典表
op = {'add':add,'update':lambda x :print(x**2),'del':lambda x:print(x*3)}  #字典表中 键'add'的值为事先定义的add函数，'update'的值为lambda表达式。lambda表达式的一般格式  ：lambda  参数1，参数2，... : 程序操作  （lambda表达式的本质就是定义了一个没有函数名的函数）

def defoult_method(x):
    print('默认方法，什么都不做')

#字典表的get(参数1，参数2)方法中的参数2 是我们指定的默认值，意思就是如果参数1代表的键在字典表中找不到的话，默认返回我们指定的默认值。
op.get('add',defoult_method)(10)   #10是参数
op.get('update',defoult_method)(10)
op.get('del',defoult_method)(10)
op.get('print',defoult_method)(10)
20
100
30
默认方法，什么都不做

Python三元运算符
在其他编程语言中三元运算符 表示方式是 条件？x:y 意思就是条件满足执行x,条件不满足执行y
而在python中表示方式是这样的 条件满足 if 条件 else 条件不满足 例如：

#三元运算符
score = 76
print('及格') if score>= 60 else print('不及格')

循环

1、while循环：

while True:
    name = input('请输入您的姓名：')  #input()函数用于让用户在键盘上输入
    if name == 'stop':
        break  # break 用于跳出整个循环
#运行结果如下：
请输入您的姓名：hello现生
请输入您的姓名：hello先生
请输入您的姓名：stop

x = 10 
while x :  #当x自减为0时 条件变为假，类的假条件还有空的字符串，空列表等
    x -=1
    if x%2 == 0:
        print(x)
        continue  # continue 用于跳出本次循环，直接进行下次循环

#运行结果如下：
8
6
4
2
0

for 循环
for循环多用于遍历数组，列表等可迭代对象
for循环的一般格式： for 临时变量 in 目标序列（可迭代对象，字符串，元组等）

for x in range(1,7):
    if x == 6:
        print('有这个数字',x)
        continue
    else:
        print('没有找到这个数字')
#运行结果如下：
没有找到这个数字
没有找到这个数字
没有找到这个数字
没有找到这个数字
没有找到这个数字
有这个数字 6

#目标序列是列表
x = [1,2,3,4,5]
for i in x:
    print(i,end = ',')
#运行结果如下：
 1,2,3,4,5,


#目标序列是元组
x = (1,2,3,4,5)
for i in x:
    print(i,end = '|')
#运行结果如下：
1|2|3|4|5|

for 循环可以用来取两个序列的交集

s1 = 'abcdefghigk'
s2 = 'helloworld'
result= []
for x in s1:
    if x in s2:  #判断s1中元素是否在s2中出现
        result.append(x)
print(result)
#运行结果如下：
['d', 'e', 'h']

#同样的，我可以采用推导的方式来解决这个问题
s1 = 'abcdefghigk'
s2 = 'helloworld'
result= [x for x in s1 if x in s2]
运行结果同上

enumerate()函数返回值有两个，第一个是每个元素的序号，第二个是每个元素的值。

s = 'abcdefg'
for index,value in enumerate(s):
    print('下标：{}，值：{}'.format(index,value))

#其运行结果如下：
下标：0，值：a
下标：1，值：b
下标：2，值：c
下标：3，值：d
下标：4，值：e
下标：5，值：f
下标：6，值：g


#遍历对象是列表
s = [1,2,3,4,5,6,7,8,9]
for index, value in enumerate(s):
    print('下标：{}，值:{}'.format(index,value))
#运行结果如下
下标：0，值:1
下标：1，值:2
下标：2，值:3
下标：3，值:4
下标：4，值:5
下标：5，值:6
下标：6，值:7
下标：7，值:8
下标：8，值:9

可迭代对象和迭代器对象

迭代器对象内置 __next()__函数，用来移动指针到下一个对象。

#例如文件对象就是迭代器对象，所以是可迭代对象。
#写文件
with open('hellwoword.txt','w',) as f:
    f.write('helloworld\n')
    f.write('你好世界\n')
#读文件
f = open('hellwoword.txt','r')
a = f.__next__()  #第一次读 文件指针在第一行
b = f.__next__()  #第二次读  文件指针在第二行
#a = next(f)  全局的next()函数
#b = next(f)
print(a,b)
运行结果如下：
helloworld
 你好世界

#同样的文件也可以用for循环来遍历
f = open('hellwoword.txt','r')
for line in f:
    print(line)
#运行结果如下：
helloworld

你好世界

字符串、元组、列表等属于可迭代对象而不属于可迭代器
所以字符串、元组、列表中并没有next（）函数，我们可用通过全局的iter()函数来判断其是否为迭代器对象

s = 'abcdefghijk'
iter(s) is s  #全局函数iter（）用于判断对象是否是迭代器对象，如果是返回True，如果不是返回Flase
s.__next__()
#运行会报错：
False
'str' object has no attribute '__next__'
 
lis = [1,2,3,4,5,6]
iter(lis) is lis
lis.__next__()
#运行也会报错
False
'list' object has no attribute '__next__'

我们也可以用iter()函数使该对象变为迭代器对象。

lis = [1,2,3,4,5]
li = iter(lis)
li.__next__()
#运行结果如下：
1

for 循环、推导、map()函数都可以在运行的过程中给可迭代对象加上___next__()函数使其变为迭代器对象

我们可以用迭代器对象做一些事情，比如：

lis = [1,2,3,4,5]
i = iter(lis)
res = []
x = 0
while True:
    res.append(next(i)**2)  #全局的next()函数用于移动指针到下一个位置，与可迭代对象内的__next__()函数相同
    x +=1
    if x ==5:
        break
res
#运行结果如下：
[1, 4, 9, 16, 25]

map()函数

def double_number(x):
    return x*2
l = [1,2,3,4,5]
result = list(map(double_number,l))  #map（参数1，参数2）函数：是将可迭代对象依次拿到方法中去运算，参数1 是方法名，参数2 可迭代对象
print(result) 
#运行结果如下：
[2, 4, 6, 8, 10]

类似的方法还有filter()函数

def evn_number(x):
    return x%2==0

l = list(range(1,11))
result = list(filter(evn_number,l))  #filter函数相当于一个过滤器，其参数和map函数一样
result
#运行结果如下：
[2, 4, 6, 8, 10]