Python 入门学习 二

基本数据类型

#coding=gbk
'''
Created on 2020年1月20日
基本数据类型
'''
from _dummy_thread import _main
"""
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：
"""
#例如
counter = 100       #整形变量
miles = 1000.0      #浮点型变量
name = "runoob"     #字符串
print(counter)
print(miles)
print(name)

#多个变量赋值
a = b = c = 1;
# 以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。
# 您也可以为多个对象指定多个变量。例如：
a,b,c, = 1,2,'runoob'
print(a)
print(b)
print(c)


###############################################3
# 标准数据类型
'''
Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
'''
 ######        整形          ##############
'''
 Python3 支持 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。
 '''
#  例子
a1,b1,c1,d1 = 20,5.5,True,4+3j
print(type(a1),type(b1),type(c1),type(d1));#<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
# 此外还可以用 isinstance 来判断：
a2 = 111;
bo= isinstance(a2, int);
print(bo);
# isinstance 和 type 的区别在于：
# type()不会认为子类是一种父类类型。
# isinstance()会认为子类是一种父类类型。


#数值运算
print(5+4);  #加法
print(4.3-2) #减法
print(3*7)   #乘法
print(2/4)   #除法 得到一个浮点数
print(2//4)  #除法 得到一个整数 
print(17%3)  #取模
print(2**5)  #乘方
# 注意：
'''1、Python可以同时为多个变量赋值，如a, b = 1, 2。
   2、一个变量可以通过赋值指向不同类型的对象。
   3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
   4、在混合计算时，Python会把整型转换成为浮点数。
 数值类型实例  
   int    float    complex
   10     0.0      3.14j
   100    15.20    45.j
   -786   -21.9    9.322e-36j
   080    32.3e+18 .876j
   -0490  -90.     -.6545+0J
   -0x260 -32.54e100  3e+26J
    0x69  70.2E-12    4.53e-7j
 Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
'''


#List<列表>
'''
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：
变量[头下标:尾下标]
'''
#索引值以 0 为开始值，-1 为从末尾的开始位置。
#加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：
list = ['abcd' , '789',2.23,'runoob',70.2]
tinylist=[123,'runoob']
print(list)              #输出完整列表
print(list[0])           #输出列表第一个元素
print(list[1:3])         #从第二个元素输出到第三个元素
print(list[2:])          #输出从第三个元素开始的所有元素
print(tinylist*2)        #输出两次列表
print(tinylist+list);    #连接列表

# 列表中的元素是可以改变的：
alist = [1,2,3,4,5,6]
alist[0] = 9
print(alist)
alist[2:4] = [2.1,3.1,4.1]
print(alist)
alist[2:5]=[]
print(alist)
# List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。
# 注意：
# 1、List写在方括号之间，元素用逗号隔开。
# 2、和字符串一样，list可以被索引和切片。
# 3、List可以使用+操作符进行拼接。
# 4、List中的元素是可以改变的。
# Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
letters = ['c','h','e','c','k','i','o']
print(letters[1:4:2])
#如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：
def reverseWords(input):
     # 通过空格将字符串分隔符，把各个单词分隔为列表
     inputWords = input.split(" ")
     
     #翻转字符串
     #假设列表 list = [1,2,3,4]
     # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样) 
     # inputWords[-1::-1] 有三个参数
     # 第一个参数 -1 表示最后一个元素
     # 第二个参数为空，表示移动到列表末尾
     # 第三个参数为步长，-1 表示逆向
     inputWords = inputWords[-1::-1];
     
     #重新组合字符串
     output = ' '.join(inputWords)
     return output
 
if __name__  == "__main__":
    input = 'I like runoob'
    rw = reverseWords(input);
    print(rw)

#Tuple(元组)
# 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
# 元组中的元素类型也可以不相同：
# 方法和list相同,值不能被修改
# 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
# 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = ()    #空元素
tup2 = (20,) #1个元素，需要在元素后添加逗号
#  string、list 和 tuple 都属于 sequence（序列）。
# 注意：
#     1、与字符串一样，元组的元素不能修改。
#     2、元组也可以被索引和切片，方法一样。
#     3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
#     4、元组也可以使用+操作符进行拼接。


# Set（集合）  无序 ，不可重复
# 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
# 基本功能是进行成员关系测试和删除重复元素。
# 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
# 创建格式：
# parame = {value01,value02,...}
# 或者
# set(value)

student = {'tom','jim','mary','tom','jack','rose'}
print(student) # 输出集合，重复的元素被自动去掉
#成员测试 
if 'rose' in student: 
    print('rose在集合中！')
else:
    print('rose 不在集合中')

#set可以进行集合运算
a = set('avsdfasdsdfasa')
b = set('alasdzam')

print(a)
print(a-b)  #a 和  b 的差集
print(a|b)  #a 和  b 的并集
print(a&b)  #a 和  b 的交集
print(a^b)  #a 和b 中不同时存在的元素

# Dictionary（字典）
#字典（dictionary）是Python中另一个非常有用的内置数据类型。
# 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
# 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
# 键(key)必须使用不可变类型。
# 在同一个字典中，键(key)必须是唯一的。

dict = {}
dict['one'] = 'one_value'
dict[2] = '2_value'
 
tinydict = {'name':'张三' ,'age' : 15,'code':1}
 
print(dict['one'])
print(dict[2])
print(tinydict)
print(tinydict.keys())
print(tinydict.values())

#构造函数 dict() 可以直接从键值对序列中构建字典如下：
dict([('runoob',1),('doogle',2),'taobao',3])
print(dict.keys())

斐波纳契数列

#coding=gbk
## 斐波纳契数列
#两个元素的总和确定了下一个数
a,b = 0,1
while b< 10:
    print(b)
    a,b = b,a+b
    # a,b = b,a+b 的计算公式为先计算右边表达式，然后同时赋值给左边
    # 0，1 = 1,0+1
    # 0,1=1,1
    # 1,1
    #循环结果为：1,1,2,3,5,8

# end 关键字:
# 关键   字end 可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符
## 斐波纳契数列
#两个元素的总和确定了下一个数
a,b,=0,1
while b < 1000:
    print(b,end =',')
    a,b = b,a+b
#     执行结果:1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

python 条件控制

#coding=gbk
'''
Created on 2020年1月23日
'''
##python 条件控制
#python条件语句是通过一条或多条语句的执行结果，true or false 来决定执行的代码块
from _ast import If

# if语句
#例子1
flag = 9
if flag < 10:
    print('小于')
elif flag == 10:
    print('等于')
else:
    print('大于')    
#注意：python 中elif 代替了else if 所以if语句的关键字为if-elif-else
#       1.每个条件后要使用: ，表示接下来是满足条件后要执行的语句块
#       2.使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块
#       3.在python中没有switch-case语句

#例子2
a=1
while a<7:
    if(a %2 ==0):
        print(a,'is even');
    else:
        print(a,'is odd')
    a += 1
    
#例子3
age = int(input('请输入你加狗狗的年龄： '))
print("")
if age <=0:
    print("你是在逗我 吧")
elif age == 1:
    print('相当于14岁的人')
elif age == 2:
    print('相当于22岁的人')
elif age>2:
    human = 22 +(age -2)* 5
    print('对应人类的年龄：',human)
    
### 退出提示
input('点击enter键退出')

## if中常用的操作符 < <= > >= == !=

# 例子4
# 数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏！")
while guess != number:
    guess = int(input('请输入你猜的数字：'))
    
    if guess == number:
        print('恭喜你猜对了')
    elif guess <number:
        print('猜的数字小了')
    elif guess>number:
        print('猜的数字大了')

# if 嵌套 
# 在嵌套if 语句中 ，可以把 if...elif...else 结构放在另外一个if...elif ...else机构中
#例子五
num=int(input('输入一个数字：'))
if num%2 == 0:
    if num%3 ==0:
        print("你输入的数字可以整除2和3")
    else: 
        print('你输入的数字可以整除2，但不能整除3')
else:
    if num%3==0:
        print('你输入的数组可以整除3，但不能整除2')
    else:
        print('你输入的数字不能整除2 和 3')
        

循环语句

#coding=gbk
'''
Created on 2020年1月23日

'''
### 循环语句
#python 中的循环语句有for 和while
#同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。


#例子1
#使用while 来计算1到100的总和
n = 100
sum =0
counter =1
while counter<=n:
    sum = sum + counter
    counter+=1
print('1到%d之和为：%d' %(n,sum))

# 无限循环 可以通过设置条件表达式永远不为false 来实现无限循环
#例子2
# var = 1
# while var==1:
#     num = int(input("输入一个数字："))
#     print('你输入的数字是：',num)
# print("Good bye")
# 无限循环在服务器上客户端的实时请求非常有用。

#while 循环使用 else语句
# 在while...else 在条件语句为false 时执行else语句块
#例子3
#循环输出数字，并判断大小
# count = 0
# while count<5:
#     print(count,'小于5')
#     count = count+1
# else :
#     print(count,'大于或等于5')

#简单语句组
# 类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中
# flag=1
# while(flag):print('无限循环')
# print('good bye')

#for 循环
sites = ['baidu','google','taobao']
for site in sites:
    if site == 'taobao':
        print('淘宝')
        break
    print("循环数据" + site)
else:
    print('没有循环数据！')
print('循环完毕')

# range（）函数
#如果你需要遍历数字序列，可以是用range()函数，他会生成数列
for i in range(5):
    print(i) #0 1 2 3 4
    
#可以使用区间
for i in range(5,9):
    print(i)#5 6 7 8

# 也可以使 range以指定数字开始应指定不同的增量，（甚至可以是负数，有时这也叫做步长）
for i in range(0,10,3):
    print(i)#0 3 6 9
#负数
for i in range(-10,-100,-30):
    print(i)#-10 -40 -70
#结合range和len()函数以遍历一个序列的索引
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
    print(i,a[i])
# 0 Google
# 1 Baidu
# 2 Runoob
# 3 Taobao
# 4 QQ

#使用range函数创建一个列表
list(range(5))

#break 和continue 语句
# break语句可以跳出for和while循环体 ，如果for活while循环中终止，任何对应的循环else 块将不执行
# continue语句被用来告诉python 跳过当前循环块中的剩余语句，然后进入下一轮循环
# 循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。
# while中使用break。

#pass 语句
# pass是空语句，是为了爆出程序结果的完整性
# pass不做任何事情，一般用作占位语句
while True:
    pass #等待键盘中断（ctrl+c） 

#最小的类
#例子
# class myEmptyClass:
#     pass

python迭代器与生产器

#coding=gbk
'''
Created on 2020年1月23日
'''
#python迭代器与生产器
# 迭代器
# 迭代器是python最强大的功能之一，是访问集合元素的一种方式
# 迭代器是一个可以记住遍历的位置的对象
# 迭代器对象从集合的第一个元素开始访问，知道所有的元素被访问完结束，迭代器只能往前不能后退
# 迭代器有两个基本的方法 ： iter() 和next()
# 字符串，列表或元组对象都可以用于创建迭代器
#例子1
from test.test_sys_setprofile import protect
list =[1,2,3,4]
it = iter(list) #创建迭代器对象
print(next(it))#输出迭代器的下一个元素

#使用常规的for语句进行遍历
it2 = iter(list)
for x in it2:
    print(x,end = " ")
    
#使用next函数
import sys # 引入sys模块

it3 = iter(list)    # 创建迭代器对象

while True:
    try:
        print(next(it3))
    except StopIteration:
        sys.exit()

创建一个迭代器

# coding=gbk
'''
Created on 2020年1月23日
'''
from test.pickletester import myclasses
from python_02 import counter

#创建一个迭代器
# 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()
# python的构造函数为__init__(),它会在对象初始化的时候执行
#__iter__()方法返回一个特殊的迭代器对象，这个迭代器对象实现了__next__()方法并通过Stoplteration异常标示迭代的完成
#__next__()方法（python2里是next（）），会返回下一个迭代器对象

#创建一个返回数字的迭代器，初始值为1 ，逐步递增1：
# 实例1
'''
class MyNumber:
    def __iter__(self):
        self.a = 1
        return self
    
    def __next__(self):
        x = self.a
        self.a += 1
        return x

myclass = MyNumber()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
'''
# Stoplteration
# StopIteration异常用于标识迭代的完成，防止出现无限循环的情况，在__next__()方法中我们可以设置在完成指定循环次数后出发StopIteration异常来结束迭代
# 在20次迭代后停止执行
# 实例2
class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self
    def __next__(self):
        if self.a<=20:
            x=self.a
            self.a +=1
            return x
        else :
            raise StopIteration
myclass = MyNumbers() 
myiter = iter(myclass)

for x in myiter:
    print(x) 
    
########################################
# 在python中，使用yield 的函数被称为生成器（denerator）
# 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器
# 在调用生成器运行的过程中，每次用到yield 是函数会暂停并保存当前所有的运行信息，返回yie  d的值，并在下一次执行next（）方法是从当前文职继续运行
#实例 ： 调用一个生成器函数，返回得到是一个迭代器对象
# 以下实例使用yield实现斐波那契数列

import sys
def fibonacci(n): #生成器函数 -斐波那契
    a,b,counter = 0,1,0
    while True:
        if(counter > n):
            return 
        yield a
        a,b = b,a+b
        counter +=1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f),end = " ")
    except StopIteration:
        sys.exit()            


#####################################