Python3入门学习二.md

#!/usr/bin/python3
#coding:utf-8
#功能:数值类型转换内置函数

print("整形 : 0xa=",int('0xa',16)," 0x12=",int('12',16)," 010=",int('10',8)) 
                                        #以16进制转换为整形,和8进制转换成为整形
print("浮点 :",float('123'),float(1))  #浮点类型
print("复数 :",complex(1,2),complex("1+2j"))  #转化一个字符串或数为复数 
#注意:这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错

cdict = dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典

print(str(cdict))  # 将对象转化为字符串形式。
print(repr(cdict))  # 将对象转化为供解释器读取的形式。

print(eval(' 2 ** 2'),eval('pow(2,2)'))  # 执行一个字符串表达式,可以执行python的一些数学函数和计算

print(set('runoob'),set('google'))       # 集合中重复的值被删除 set
print(frozenset(range(10)))              # 生成一个新的不可变集合 set

print(chr(48),chr(65),chr(97))       #将ASCII码 ==> 字符
print(ord('0'),ord('A'),ord('a'))    #将字符  ==> ASCII
print(hex(255),hex(15))
print("255 oct =",oct(255),"10 oct =",oct(10))

#!/usr/bin/python3
#coding:utf-8
#功能:特殊运算符号验证demo
#"""Python算术运算符"""
print("2 / 4 = ", 2 / 4)   #除法 , 得到浮点数
print("2 // 4 = ",2 // 4)  #除法 , 得到整数
print("2 ** 4 = ",2 ** 4)  #乘方 ，(优先级最高)
print("5 % 4 = ",5 % 4)   #取余 ，

#"""比较运算符###
a = 1
b = 2
if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")

#"""赋值运算符###
c = a + b
c += 1
print("C值为：",c)
c **= c
print("C值为：",c)

#"""Python位运算"""
a = 1
b = 8
print("a&b = ", a&b)  #与
print("a|b = ", a|b)  #或
print("a^b = ", a^b)  #亦或
print("~a = ", ~a)    #取反
print("a<<2 = ", a<<2)   #左移动

#"""Python逻辑运算符"""
a = 1
b = 2
print((a and b))  #如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
print((a or b))   #如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
print(not(a or b)) # 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。


#"""Python成员运算符"""
a = 10
b = 5
list = [1, 2, 3, 4, 5 ]
if(a in list):
    print("a 在list列表里面")
else:
    print("a 不在list列表里面")

if(b not in list):
    print("a 不在list列表里面")
else:
    print("b 在list列表里面")

#"""Python成员运算符"""
a = 20
b = 20
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
#注： id() 函数用于获取对象内存地址
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")


a,b,c,d,e = 20,10,15,5,0
#"""算术运算符优先级验证""" 
e = (a + b) * c / d       #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：",  e)
 
e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：",  e)
 
e = (a + b) * (c / d);    # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：",  e)
 
e = a + b * c / d;      #  20 + (150/5)
print ("a + (b * c) / d 运算结果为：",  e)

if 表达式:
    执行语句
elif 表达式:
    执行语句
else:
    执行语句
    
#三元操作符    
x if 条件 else y    //如果条件为真时候将x值赋给small，为假时候将y值赋给small


#else 语句
1) else 语句跟 if 语句搭，构成“要么怎样，要么不怎样”的语境
2) else 语句跟 for / while 语句搭，构成“干完了能怎样，干不完就别想怎样”的语境
2) else 语句跟 try 语句搭构成“没有问题，那就干吧”的语境

while （表达式条件):
          为真则执行代码块
else:
        语句为 false 时执行该 else 的语句块： 
  
  
for 变量 in 表达式:
          循环体
else:
          它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。

#!/usr/bin/python3
#coding:utf-8
#功能:分支与循环
#-----------if 语句-----------------
guess = 8
temp = int(input("请输入一个1-10数值:"))
if guess == temp:
    print("恭喜您,输入的数值刚好")
elif guess > temp:
    print("太遗憾了,输入的数值小于它")
else:
    print("太遗憾了,输入的数值大于它")

x,y = 1,3
print("#三元运算符 ：",end="")
print( x if x > 3 else y )


#------------while 语句---------------
# Fibonacci series: 斐波纳契数列 （两个元素的总和确定了下一个数）
a,b = 0,1
while b < 10:
    print(b,end=",")
    a,b = b, a+b
print("nn")   

while (1): print ('Python!')

#采用while ..else 进行素数的计算
count  = 11 / 2 
while count > 1:
       if num % count == 0:
             print("%d 最大约数是%d " %（11,count))
             break   #利用break跳出不执行else
             count -= 1
else:
             print("%d是素数" 11)   #循环穷尽（为假的时候，执行遇到break不会执行）



#------------for 语句---------------
for i in "python":
  print(i,end="|")  #依次打印字母并以 | 分割
print()   

sites = ["baidu","Google","Runoob","taobao"]
for i in sites:
    print(i,end=",")       #打印出列表的值
print()   

for i in range(len(sites)):  #或列表的长度 4 生成(0 - 3);
    print(i,sites[i],len(sites[i]))  #索引,列表中以索引下标的元素,元素的长度

print()   
#查询是否为质数 2 - 10 那些是质数
for x in range(2,10):
    for y in range(2,x):
        if x % y == 0:
            print(x,'等于',y , '*', x // y)
            break
    else:
        #循环中找到元素,它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。 
        print(x,'是质数')

while True:
    pass  # 等待键盘中断 (Ctrl+C)
    
#最小的类:
class MyEmptyClass:
   pass

#!/usr/bin/python3
# coding:utf-8
# 功能：迭代器与生成器

import sys          #引入 sys 模块
list = [1, 2, 3, 4]
it = iter(list)

#** 方法1 for **#
## 其实 for 语句实现与iter迭代器差不多 ##
for x in it:
    print("值", x, end=", ")
else:
    print("n---------------------------")


#***方法2 next**#
it = iter(list)
while True:
    try:
        print(next(it), end=",")
    except StopIteration:     # StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况;
        sys.exit()


#**方法3 迭代器 - 魔法方法 **#
# 创建一个返回数字的迭代器，初始值为 0，逐步递增 1：运行四次
#魔法方法案例(1)
class MyNumbers:
    def __iter__(self):  #魔法方法
        self.a = 0 
        return self

    def __next__(self):  #当
        try:
            if self.a <= 3:
                x = self.a
                self.a += 1
                return x
            else:
                raise StopIteration
        except StopIteration:
            return ('迭代结束')

myclass = MyNumbers()
myiter = iter(myclass)  # 实际触发了__iter__ 中 a = 0
print(next(myiter), end=" ")  #运行1次 next
print(next(myiter), end=" ")  #运行2次 next
print(next(myiter), end=" ")  #运行3次 next
print(next(myiter), end=" ")  #运行4次 next
print(next(myiter))  #第五次运行next由于条件(或抛出 StopIteration 退出迭代)

#案例二：采用魔法方法实现斐波那契数列
class Fibs:
    def __init__(self):
        self.a = 0
        self.b = 1

    def __iter__(self):
        return self   #返回它本身由于它自身就是迭代器

    def __next__(self):
        self.a, self.b = self.b,self.a + self.b
        return self.a   #a就是下一个斐波那契的值
    # def __next__(self):
    #     self.a, self.b = self.b,self.a + self.b
    #     if self.a > 10:
    #         raise StopIteration   #表示
    #     return self.a

fibs = Fibs()
for each in fibs:
    if each < 20: #返回
        print(each, end=" ")
    else:
        break


#######################
# $ python demo3.24.py
# 0 1 2 3 迭代结束
# 1 1 2 3 5 8 13

#!/usr/bin/python3
#功能：生成器yield
import sys
 
#案例1：
def gener():
    print("生成器被执行!",end=" ")
    yield 1  #运行第一next 暂停在这里
    yield 2  #运行第二next 显示二

my = gener()
next(my)  # 成器被执行! 2
next(my)  # 2


#方法2：
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        #当 counter == 10 结束（即算出10次数）
        if (counter > n): 
            return
        yield a  #生成器进行返回
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print(next(f), end=" ") #一次返回一个斐波那契数列 0 1 1 2 3 5 8 13 21 34 55
    except StopIteration:
        sys.exit()


#方法3：for循环会自动解析Stopiteration异常并结束
def fbli():
    a = 0
    b = 1
    while True:
        a, b = b, a+b
        yield a

for each in fbli():  #each 及是 返回生成器 a的值
    if each <= 55:
        print(each,end=" ")
    else:
        break

########## 执行结果 ##########
# 1 2 3 5 8 13 21 34 55

#.__doc__ (函数的默认属性,他是一个特殊的属性,特殊属性格式就是这样)
def 函数名(形参列表):
      '函数文档 ：通过 函数名.__doc__调用' 
      函数体


#(形参) formal parameters
#(实参) actual parameters
def first(name="default"):
       '函数定义过程中name是形参' #因为ta只是一个形式，表示占据一个参数位置。
       print(name,"这时候name的值是实参，因为他是具体的参数值！")

>>> def hello():
    print("hello world")     #由于这里没有return 语句，将返回None
>>> temp = hello()     #将函数的值返回给temp
hello world    
>>> temp                    #但是temp并没有return返回值
>>> print(temp)   
None                             #Print-Temp时候返回了None类型
>>> type(temp)
<class 'NoneType'>


>>> def back():
    return ["Python","Flash", 3.1415926]
>>> back()
['Python', 'Flash', 3.1415926]     #返回列表
 
>> def back():
    return "Python","Flash", 3.1415926
>>> back()
('Python', 'Flash', 3.1415926)   #返回元组

#!/usr/bin/python3
#功能：实现函数功能

def fun(num1,num2):
    '函数功能：求出两个数之和'  #通过 函数名.__doc__调用函数文档
    return num1 + num2        #用return返回参数或者程序运行的结果

def saypython(name='小甲鱼',words="改变时间"):  #设置默认参数，当未给函数赋值的时候显示
    '函数文档：我们的心声'
    print(name + ' 想 ->' + words)

print("1 + 2 =",fun(1,2))
print("函数说明：(",fun.__doc__,end=")n-------------")
print("我",saypython('weiyigeek','改变世界'))  #由于无return语句则返回none

saypython('weiyigeek','改变世界')
saypython()  #采用函数默认参数,便可以不带参数运行,因为有内置可选参数 name='小甲鱼',words="改变时间"

print("函数说明：(",fun.__doc__,end=")n")

#!/usr/bin/python3
#功能：函数参数
#例如：其实PRINT()就自带收集参数*Objects
#print(*objects, sep=' ', end='n', file=sys.stdout, flush=False) 

#/*不可变对象**/
def ChangeInt(a):
    a = 10
    print("(不可变)函数内：",a) #结果是 10

b = 2
ChangeInt(b)
print("(不可变)函数外：",b,end="nn") #结果是 2

#/*可变对象**/
def changeme(mylist):
    mylist.append([1,2,3,4])  #这时候传入列表已经被改变了
    print("(可变)函数内取值 :",mylist)  
    return
mlist = [6,6,6]
changeme(mlist)
print("(可变)函数外取值 :",mlist)  #列表已改变

#!/*** 可变参数(*) 与 关键字参数 **/
def test(*params,exp="weiyi"):
    print("参数长度 :",len(params)," 第二个参数：",params[1],"Name :",exp)
    for var in params:
        print(var,end=",")
    return 0

test(1,"爱您",1024,1,exp='weiyigeek')

#!/*** 可变参数(**) **/
def printmm(arg1,**vardict):
    '函数文档：形式参数为字典类型'
    print("nn输出 arg1：",arg1)
    print("输出 vardict 字典 :",vardict)

printmm('test',a=1,b=2,c=3)

#!/*** 单个星号的使用  (注意)**/
def star(a,b,*,c):
    print("a :",a ," b:",b ,' c:', c)

star(1,2,c=1024)  #c必须进行指定关键字传入值，否则会报错

#!/usr/bin/python3
#功能：使用匿名函数

#函数定义
sum = lambda arg1,arg2: arg1 + arg2
sum.__doc__ = '函数文档'

#调用匿名函数
print("1 + 99 相加后的值 :",sum(1,99))
print(sum.__doc__)


#进阶用法和BIF内置函数filter/map的使用
#匿名函数进阶 (设置过滤函数，返回可以不可以整除2的数值)
show = list(filter(lambda x: x % 2,range(10)))
print(show)

#进行map映射显示被%2整除后的结果。
show = list(map(lambda x:x % 2,range(10)))
print(show)

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域
#内置作用域是通过一个名为 builtin 的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。

#!/usr/bin/python3
#代码功能：全局与局部变量Variable

#msg 变量定义在 if 语句块中，但外部还是可以访问的
if True:
    msg = "I am from Weiyigeek"
print("nmsg 变量定义在 if 语句块中，但外部还是可以访问的:",msg)

def discount(price,rate):
    final_price = price * rate   #局部变量
   # print("这里试图打印全局变量old_price的值(回报错):",old_price)

    local_price = 100    #定义在函数中,则它就是局部变量,外部不能访问
    print("局部变量local_price :",local_price)   # 100

    old_price = 50
    print("函数内修改后old_price的值是1 :",old_price)
    return final_price

old_price = float(input('请输入原价：'))
rate = float(input('请输入则扣率: '))
new_price = discount(old_price,rate)
print('函数外修改后的old_price的值是2 :',old_price)
print('打折后的价格 :',new_price)

#!/usr/bin/python3
#功能：全局变量作用域和非全局作用域

"""global"""
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print("global:",num,end=",") 
    num = 123
    print(num,end=",")
    num += 133
fun1()
print(num)  
#global: 1,123,256


"""nonlocal"""
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print("nonlocal:",num,end=" | ")
        num *= 10.24
    inner()
    print(num,end=" | ")
outer()
print(num)  #这里的num没有变化由于outer函数中没有使用global关键字
#nonlocal: 100 | 1024.0 | 256

#!/usr/bin/python3
#功能：内嵌函数与闭包使用

#""" 内嵌函数 """
def fun1():
    print("Fun1 主函数被调用")
    def fun2():
        print("Fun2 内嵌函数正在被调用n")
    fun2()  #内部函数（内嵌函数）,只能由fun1()调用

fun1()



#"""闭包"""
def funX(x):
    def funY(y):
        return x * y
    return funY

i = funX(8)
print("i的类型 :",type(i))
print("8 * 5 =",i(5)) #  40 由于前面已经赋值给x了,后面得就给了y=5.
"""
#类似于：
def funX(x):
    def funY(y):
        return x * y
    return funY(2)
>>> funX(3)
6
"""



#"""闭包进阶（采用类似于数数组的方式 -- 列表(传入的是地址)）"""
def demo1(arg):
    x = [arg]
    def demo2():
        #采用 nonlocal 关键字也行
        x[0] **= x[0]  #采用这样的方式进行取值列表 (**幂运算) | 不引用局部变量(Local variable),采用数组的方式进行暗渡成仓.
        return x[0]
    return demo2()

print("2 ** 2 =",demo1(2),"  -  5 ** 5 =",demo1(5))

#"""一个闭包的典型案例"""
def funA():
    x = 5
    def funB():
        nonlocal x   #//把x强制表示不是局部变量local variable
        x += 13
        return x 
    return funB

a = funA()  #当 a 第一次被赋值后,只要没被重新赋值,funA()就没被释放,也就是说局部变量x就没有被重新初始化。
print("第一次调用：",a(),"第二次调用：",a(),"第三次调用：",a())