python学习小记

#  print  的一些使用

# 1、逗号分隔打印多个
print('asd',',',1,'vsv')

# 2、加号  进行字符串相加
print('asd'+',',1,'vsv')

# 3、sep = "-"  使用制定的字符串进行链接字符
print('my','name','is','hexianmin',sep='-')

# 4、指定打印结束的字符     end = ''  可以替换掉换行符    可以使两个print之间默认的换行符取消
print('hello ',end='')   #取消了换行符
print('world')


# import导入重命名
# 1
import math

# 2 
import math as mt

# 3
from math import sqrt as mat

# 4 
from math import pow,sqrt  

# 5
from math import *


# 赋值魔法 ：

# 1、序列解包
values = (1,2,3)
x,y,z = values
print(x,y,z)

# 当序列解包  左部个数少于右部  不处理会报错  但是用运算符  （ * ） 可以来收集多余的值  这样无需确保变量的个数相同
x0,*rest,y0 = values
print(x0,rest,y0)   #但是要注意的是  使用 * 收集到的值都是列表  

# 2、链式赋值
x1 = y1 = 10    #这样等价于 x1 = 10     y1 = 10

# 3、增强赋值
x2 = 2
foor = 'asd'
x2 += 1
foor *= 2
print(x2,foor)

# 4、赋值的一点小区别   下面两个列子  可以看出  链式赋值是指向同一个地址（也就是说对象是同一个）  而分别赋值是指向两个不同的地址  是不同的对象    用 is  和  == 进行判断区别很明显                                        
# 第一：  指向同一个对象
x11 = y11 = [1,2]
print(id(x11),id(y11))

# 第二：  指向不同对象
x11 = [1,2]
y11 = [1,2]
print(id(x11),id(y11))



# is  相同运算符     注意区别  is  和  ==  :  1、is 是检查两个对象是否相同（就是指向同一个地址）   2、 ==  是检查两个对象是否相等  地址不一样但是相等也为 True                                         
x11 = [1,2]
y11 = [1,2]
print(x11 is y11,'  ',x11 == y11)    #output： False    True    这个例子很明显看出来其中的区别


# 字符串 和 序列 的比较  是看顺序来比较的 （从左往右）  如下
'abcd' < 'b'    #output: True    因为第一个 a<b  所以后面不比较了  直接返回True
[1,2,[5,6]] < [2,1,[3,4]]   #output: True     因为第一个 1 < 2  后面不比较了 直接返回True   即使后面  [3,4] < [5,6]



# bool 运算 ： or  and   not
not True    #非运算     字面意思理解  (不在  不是 ) 的意思


# 断言  assert     当出现 假 没有处理时  激活断言模块 执行  告诉程序员 哪个地方有bug
#  age = -1
#  assert 0 < age and age < 100,"dc"


# 迭代字典  就像迭代  列表一样   用  成员资格运算符  字典也支持序列解包
d = {
    'd':1,
    'c':2,
    'f':3
}
for key,value in d.items():    #items() 返回一个一个的项  返回的项是无顺序的
    print(key,':',value)
    
# enumerate(str)  这是一个内置函数  这个函数让在使用 成员资格 时   也可以拥有下标索引  而且下标索引是自动提供的
for index , value1 in enumerate('abcdefg'):   #默认第一个为下标索引  自动递增  第二个为取值
    print(index,value1,'\n')

    
# 并行迭代工具 zip 函数
he = ['h','x','m']
xi = [1,2,3]
zip(he,xi)     #是一个迭代器  可以转换为列表 和 元组
list(zip(he,xi))


# sorted 返回一个列表       reversed 返回一个迭代器  可以转换为元组和列表   而且也可以使用join  如下
''.join(reversed('asdfg'))


# 简单推导 
[(x,y) for x in range(3) for y in range(4) if x == y]     # 这个为列表推导     注意没有元组推导  最外层使用圆括号（元组）   得到的是 生成器  不是元组                             
print({i:'{} is {} day(s)'.format('today',i) for i in range(7)})


# 赋值再重现 之  1、' ={} '   2、 '= None'   3、 'del a'    这三种方法  在执行后  都是将一者的'指针'指向改变了  而不会影响其他值    如下
test1 = 'sadasd'
test2 = test1
print(test1,test2)

test1 = None    #不影响test2   因为只将test1的'指针指向改变了'  然而 字符串'sadasd'还存在存储空间中  而且test2还指向它  所以test2还是'sadasd'
print(test1,test2)

test1 = {}    #道理同上   test1 = {}   test2 = 'sadasd'
print(test1,test2)

del test1    #道理同上   test1 连名字都删除了  更不可能有指向的说法了   test2 = 'sadasd'    del是将名字和指向全部删掉   但是不会改变'sadasd'本身的存储  也不影响test2
#print(test1,test2)

#python有垃圾自动清理功能  当没有使用的就会被删除


# exec 和 eval 
# eval()函数和exec()函数的区别：
# 1、eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段
# 2、eval()函数可以有返回值，而exec()函数返回值永远为None（无法进行赋值获取）

#  eval(source, globals=None, locals=None, /)
#  exec(source, globals=None, locals=None, /)
#  都是三个参数  第一个参数为必选项    第二个参数为全局变量   第三个参数为局部变量    
#  1、若 全局、局部都没有  直接调用全局变量   
#  2、若 全局有  局部没有   调用globals中定义的
#  3、若 全局有  局部有    相同的取局部的  其他的也以局部为主
#  4、若 全局没有  局部有   以局部为主         以局部为主

#例子
x = 10
def func():
    y = 20   #局部变量y
    a = eval("x+y")
    print("a:",a)      #x没有就调用全局变量
    b = eval("x+y",{"x":1,"y":2})     #定义局部变量，优先调用
    print("b:",b)
    c = eval("x+y",{"x":1,"y":2},{"y":3,"z":4})  
    print("c:",c)  
    d = eval("print(x,y)")
    print("d:",d)   #对于变量d，因为print()函数不是一个计算表达式，因此没有返回值
func()


x = 10
expr = """
z = 30
sum = x + y + z   #一大包代码
print(sum)
"""
def func():
    y = 20
    exec(expr)   #10+20+30
    exec(expr,{'x':1,'y':2})    #30+1+2
    exec(expr,{'x':1,'y':2},{'y':3,'z':4}) #30+1+3，x是定义全局变量1，y是局部变量  注意z=30
func()
# 主要以expr中的变量值为主   再以局部locals为主   再以globals为选择   最后都没定义就找全局变量