Python 语法基础（二）

一、运算符和表达式

功能注释：
1、+运算符除了用于算数加法以外，还可以用于列表、元组、字符串的连接，但不支持不同类型的对象之间相加或相连。

#连接两个列表1,2,3] + [4,5,6] ---> [1, 2, 3, 4, 5, 6]
print([1,2,3] + [4,5,6])
#连接两个元组 (1,2,3)+(4,) --->(1,2,3,4)
print((1,2,3)+(4,))
#连接两个字符串 ‘abc' + 'defl' ----> 'abcdef'
print('abc' + 'defl')

##接下来就要见证奇迹了
print(True + 2)  # 自己思考一下，此处的运算是否会出错
print(False + 3)

##不支持不同类型之间的相加，如
print('A'+1)   #抛出异常 TypeError: can only concatenate str (not "int") to str


运算结果：
E:\project\Python\projectTopy\venv\Scripts\python.exe E:/project/Python/projectTopy/Test.py
[1, 2, 3, 4, 5, 6]
(1, 2, 3, 4)
abcdefl
3
3
Traceback (most recent call last):
  File "E:/project/Python/projectTopy/Test.py", line 14, in <module>
    print('A'+1)   #抛出异常 TypeError: can only concatenate str (not "int") to str
TypeError: can only concatenate str (not "int") to str

Process finished with exit code 1

2、“星”运算符不仅可以用于数值乘法，还可以用于列表、字符串、元组等类型，当列表、字符串或元组等类型变量与整数进行“*”运算时，表示对内容进行重复并返回重复后的新对象。

print(2.0 * 3) #浮点数与整数相乘 
print((3 + 4j) * (3 - 4j))  #复数与整数相乘 
print("a" * 10)    #字符串重复
print([1,2,3] * 3)     #列表重复
print((1,2,3) * 3)   #元组重复 

运行结果：
E:\project\Python\projectTopy\venv\Scripts\python.exe E:/project/Python/projectTopy/Test.py
6.0
(25+0j)
aaaaaaaaaa
[1, 2, 3, 1, 2, 3, 1, 2, 3]
(1, 2, 3, 1, 2, 3, 1, 2, 3)

Process finished with exit code 0

3、Python 中的除法有两种，‘ / ’ 和 ‘//’分别表示除法和整除运算

print(3 / 5)
print(3 // 5)
print(3.0 / 5)
print(3.0 // 5)
print(13 / 10)
print(-13 // 10)

运行结果：
E:\project\Python\projectTopy\venv\Scripts\python.exe E:/project/Python/projectTopy/Test.py
0.6
0
0.6
0.0
1.3
-2

Process finished with exit code 0

4、关系运算符可以连用，一般用于同类型对象之间值得大小比较，或者测试集合之间的包含关系。

print(3 < 5 < 6)
print(3 < 2 < 6)  #等价于 3 < 2 and 2 < 6
print('hello'  > 'xixixxi') #比较字符串大小
print([1,2,3] < [1,2,4]) #比较列表大小
print({1,2,4} < {1,2,3,4})  #测试是否子集

print('hello' > 3)  #字符串和数字不能比较

运算结果：
E:\project\Python\projectTopy\venv\Scripts\python.exe E:/project/Python/projectTopy/Test.py
True
False
False
True
True
Traceback (most recent call last):
  File "E:/project/Python/projectTopy/Test.py", line 7, in <module>
    print('hello' > 3)  #字符串和数字不能比较
TypeError: '>' not supported between instances of 'str' and 'int'

Process finished with exit code 1

5、成员测试运算符 in 用于 成员测试，即测试一个对象是否为另一个对象的元素

print(3 in [1,2,3])  # 测试3是否在列表[1,2,3]中
print(5 in range(1,10,1))  #range()用于来生成指定范围数字的内置函数
print('abc' in 'abcdefg')  #子字符串测试
for i in (3,5,7):    #循环，成员遍历
    print(i , end = '\t')  # 注意，这里打两个回车会执行
执行结果：
E:\project\Python\projectTopy\venv\Scripts\python.exe E:/project/Python/projectTopy/Test.py
True
True
True
3	5	7	
Process finished with exit code 0

6、同一性测试运算符（identity comparison） is 用来测试两个对象是否是同一个，如果是则返回True,否则返回False。如果两个对象是同一个，两者具有相同的内存地址。

print(3 is 3)
x = [300,300,300]
print(x[0] is x[1])  #基于值的内存管理，同一个值在内存中只有一份
x = [1,2,3]
y = [1,2,3]
print(x is y)   #上面形式创建的 x和 y不是同一个列表对象

运行结果：
E:\project\Python\projectTopy\venv\Scripts\python.exe E:/project/Python/projectTopy/Test.py
True
True
False

Process finished with exit code 0

7、位运算符只能用于整数，其内部执行过程为：首先将整数转换为二进制数，然后右对齐，必要的时
候左侧补0，按位进行运算，最后再把计算结果转换为十进制数字。

print(3 << 2)  #把3左移2位（ 11 左移两位 1100-->12）
print(3 & 7)   #位与运算 (0011 & 0111 ==> 0011(3))
print(3 | 8)   #位或运算(0011 & 1000 ==>1011(11))
print( 3 ^ 5)  #位异或运算(0011 ^ 0101 -->0110(6))

运算结果：
E:\project\Python\projectTopy\venv\Scripts\python.exe E:/project/Python/projectTopy/Test.py
12
3
11
6

Process finished with exit code 0

位运算符规则：

8、集合的交集、并集、对此差集等运算借助于位运算符来实现，而差集则使用减号运算符实现（注意，并集运算符不是加号）

 print({1, 2, 3} | {3, 4, 5})         #并集，自动去除重复元素
 # {1, 2, 3, 4, 5} 
 print({1, 2, 3} & {3, 4, 5})         #交集 
 #  {3} 
 print({1, 2, 3} ^ {3, 4, 5})         #对称差集 
 # {1, 2, 4, 5} 
 print({1, 2, 3} - {3, 4, 5}         #差集 
 # {1, 2} 

9、and 和 or 具有惰性求值特点，只计算必须计算的表达式

print( 3>5 and a>3)     #注意，此时并没有定义变量a 
# False 
print(3>5 or a>3)      #3>5的值为False，所以需要计算后面表达式 
# NameError: name 'a' is not defined 
print( 3<5 or a>3 )      #3<5的值为True，不需要计算后面表达式 
# True 
print( 3 and 5 )        #最后一个计算的表达式的值作为整个表达式的值
# 5 
print( 3 and 5>2 
# True 
print (3 not in [1, 2, 3] )  #逻辑非运算not 
# False 
print( 3 is not 5 )           #not的计算结果只能是True或False之一 
# True
 

10、矩阵相乘运算符 @

import numpy		#numpy是用于科学计算的Python扩展库
x = numpy.ones(3)	#ones()函数用于生成全1矩
m = numpy.eye(3)*3	 #eye()函数用于生成单位矩阵
m[0,2] = 3			#设置矩阵指定位置上元素的值
m[2,0] = 5
print(x @ m )     #矩阵相乘 
#array([6.,3.,8.])

11、 , 逗号并不是运算符，只是一个普通分隔符

print( 'a' in 'b', 'a' )
# (False, 'a') 
print('a' in ('b', 'a'))
# True 
x = 3, 5
print(x )
# (3, 5) 
print( 3 == 3, 5)
#  (True, 5)
x = 3+5, 7 
print(x)
# (8, 7)

12、Python不支持++和–运算符，虽然在形式上有时候似乎可 以这样用，但实际上是另外的含义。

i = 3  
print(++i)                       #正正得正 
3 
print(+(+3))                     #与++i等价
3
print(i++)                       #Python不支持++运算符，语法错误 
SyntaxError: invalid syntax 
print(--i)                      #负负得正 
3 
print( -(-i) )                    #与--i等价
 3 

13、在Python中，单个任何类型的对象或常数属于合法表达式，使用运算符连接的变量和常量以及函数调用的任意组合也属于合法的表达 式。

a = [1,2,3]
b = [4,5,6]
c = a + b
print(c)
# [1, 2, 3, 4, 5, 6]
d = list(map(str, c)) 
/**
map是python内置函数，会根据提供的函数对指定的序列做映射。
map()函数的格式是：

map(function,iterable,...)
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。

把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。
*/

print(d)
# ['1', '2', '3', '4', '5', '6'] 
import math 
print( list(map(math.sin, c)))
 #[0.8414709848078965, 0.9092974268256817, 0.1411200080598672, 0.7568024953079282, -0.9589242746631385, -0.27941549819892586] 
 print('Hello' + ' ' + 'world' )
 #'Hello world' 
 print( 'welcome ' * 3 )
 # 'welcome welcome welcome ' 
 print(('welcome,'*3).rstrip(',')+'!' )
 #strip() 函数来去除字符串或者字段前后的空格，
 #而是用来删除字符串末尾的指定字符（默认为空格）
 # 'welcome,welcome,welcome!'

二、常用内置函数

1、内置函数不需要导入任何模块即可使用
2、执行下面的命令可以列出所有内置函数 >>> dir(builtins)

1、dir()函数可以查看指定模块中包含的所有成员或者指定对象类型所支持的操作。
2、 help()函数则返回指定模块或函数的说明文档。

from turtle import *
import time

print(dir(time))
print(help(time))

运行结果：

3、内置函数bin()、oct()、hex()用来将整数转换为二进制、 八进制和十六进制形式，这三个函数都要求参数必须为 整数

print(bin(12))
#输出结果为： 0b1100
print(oct(12))
#输出结果为：0o14
print(hex(12))
#输出结果为： 0xc

4、内置函数int()用来把实数转换为整数，或把数字字符串按指定进制转换为十进制数

print(int(3.5))
# 3
print(int(-3.5))
# -3
print(int('1011',2))
#11
print(int('1011',16))
#4113 （16进制）
print(int('x2',36))
#1190 （36进制）
print('\t 8 \n')
# 8 （自动忽视数字两侧的空白字符）

5、ord()和chr()是一对功能相反的函数，ord()用来返回 单个字符的序数或Unicode码，而chr()则用来返回某序 数对应的字符，str()则直接将其任意类型参数转换为 字符串

print(ord('a'))  #97
print(chr(ord('a')+1)) # b
print(str(1234)) # 1234
print(str((1,2,3))) #(1，2,3）
print(chr(97)) # a
print(str(1)) # 1
print(str([1,2,3])) # [1,2,3]
print(str({1,2,3})) # {1,2,3}

6、max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他 可迭代对象中所有元素最大值、最小值以及所有元素之和，sum()要求 元素支持加法运算，max()和min()则要求序列或可迭代对象中的元素之 间可比较大小。

import random
a = [random.randint(1, 100) for i in range(10)]  # 列表推导式
print(a)
print(max(a), min(a), sum(a)) 

自己试着想想，如何计算出一个列表中的所有元素的平均值？保持你们的好奇，我等待你们在留言区的回答。
7、内置函数max()和min()的key参数可以用来指定比较规则max()和min()的高级用法

x = ['22','1111','9']
print(max(x)) # 默认数据为字符串数组，从而输出最后一个字符串
print(max(x,key = len)) # (key为一个函数，规定比较规则，此处设置为该数组中数据的长度）
print(max(x,key = int)) # 规则设置数组中的数据为int类型，同时进行比较

#最生动的例子。说明Key的作用
from random import randrange
x = [[randrange(1,100) 
for i in range(10)] 
	for j in range(5)] 
	
for item in x:  print(item)   
'''
[15, 50, 38, 53, 58, 13, 22, 54, 7, 45] 
[45, 63, 58, 89, 85, 91, 77, 45, 53, 50] 
[80, 10, 46, 16, 71, 73, 13, 68, 94, 50] 
[66, 4, 49, 67, 26, 58, 52, 46, 69, 99]
[35, 57, 63, 35, 71, 18, 86, 2, 16, 87]
'''
print(max(x, key=sum))       
#求所有元素之和最大的子列表 
[45, 63, 58, 89, 85, 91, 77, 45, 53, 50] 

8、 内置函数sum()的start参数可以实现非数值型列表元素 的求和

print(sum([1,2,3,4])) #求和整个数组的和
print(sum([[1],[2],[3],[4]],[])) # 求非数组类型元素的总和

9、内置函数type()和isinstance()可以判断数据类型

#type（）函数
print(type([3])  #查看[3]的数据类型
print(type({3}) in (list,tuple,dict)) # 判断{3}是否为list（数组）、tuple（元组）、dict（字典）类型的实例
#isintstance()函数
print(isinstance(3,int))
print(isinstance(3j,(int,float,complex))) #判断3j是否为int \float\complex类型

10、sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表sort()\sorted()\argsorted()的使用及其区别

 x = ['aaaa', 'bc', 'd', 'b', 'ba'] 
print(sorted(x, key=lambda item: (len(item), item))) 
#先按长度排序，长度一样的正常排序 ['b', 'd', 'ba', 'bc', 'aaaa']

#、、、、
import random 
data = random.choices(range(50), k=11) #在50以内随机选择11个数
print(data)
'''[18, 38, 35, 5, 13, 48, 13, 2, 19, 47, 3]''' 
print(sorted(data) )
#[2, 3, 5, 13, 13, 18, 19, 35, 38, 47, 48] 
sorted(data)[len(data)//2]  #中位数 
#18 

11、 reversed()对可迭代对象（生成器对象和具有惰性求值 特性的zip、map、filter、enumerate等类似对象除外 ）进行翻转（首尾交换）并返回可迭代的reversed对象。（惰性求值也叫延迟求值，顾名思义就是表达式不会在它被绑定到变量之后就立即求值，而是等用到时再求值。延迟求值的一个好处是能够建立可计算的无限列表而没有妨碍计算的无限循环或大小问题。）

x = ['aaa','bc','d','b','ba']
print(reversed(x))  #逆序，返回可迭代的reversed对象
print(list(reversed(x))) #reversed对象是可迭代的
'''
## 输出结果：
<list_reverseiterator object at 0x0000021DB1F20788>
['ba', 'b', 'd', 'bc', 'aaa']
'''

12、 range()语法格式为range([start,] end [, step] )，返 回具有惰性求值特点的range对象，其中包含左闭右开 区间[start,end)内以step为步长的整数。参数start默认 为0，step默认为1。 range教程

print(range(5))  #range(0, 5),start默认为0，step为1
print(list(range(5)))
print(list(range(1,20,4))) #1为start开始，20为end终止，4为step步长
#设置负步长
print(list(range(10,0,-2))) #设置负数步长时，start必须大于end

13、 enumerate()函数用来枚举可迭代对象中的元素，返回 可迭代的enumerate对象，其中每个元素都是包含索 引和值的元组。 enumerate使用说明

print(list(enumerate('abcd')))   #枚举字符串中的元素
print(list(enumerate(['Python','Greate']))) #枚举列表中的元素
print(list(enumerate({'a':97,'b':98,'c':99}.items())))  #枚举字典中的元素
for index , value in enumerate(range(10,15)): #枚举range对象中的元素
	print((index,value),end = '')
'''
输出结果：
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
[(0, 'Python'), (1, 'Greate')]
[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]
(0, 10)(1, 11)(2, 12)(3, 13)(4, 14)
'''	

14、 内置函数map()把一个函数func依次映射到序列或迭代器 对象的每个元素上，并返回一个可迭代的map对象作为结 果，map对象中每个元素是原序列中元素经过函数func处 理后的结果。 map使用教程

print(list(map(str,range(5))) ) #把列表中元素转换为字符串
#定义adds函数
def adds(v):
	return v+5

print(list(map(adds,range(10))))#把单参数函数映射到一个序列的所有元素

#定义add函数
def add(x,y):
	return x+y

print(list(map(add,range(5),range(5,10)))) #把双参数函数映射到两个序列上

def myMap(iterable ,op ,value): #实现序列与数字的四则运算
	if op not in '+-*/':
		return 'Error operator'
	func = lambda i :eval(repr(i) + op + repr(value))
	return map(func,iterable)

list(myMap(range(5),'+',5))
list(myMap(range(5),'-',5))
list(myMap(range(5),'*',5))
list(myMap(range(5),'/',5))
def digitsum(n) : #计算整数各位之和
	return sum(map(int,str(n)))
digitsum(1729)