pyhon的数据类型

1.数字

整型和浮点型

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

一般是用到语法是int() 将数据类型强制转换为整型

2.布尔

真或假

1或0

3.字符串

一般常用的功能实现：

移除空白

print("\n            i have a dream".strip())

分割

name = "i have a dream"

print(name.split())

长度

name = "i have a dream"

print(len(name))

索引

name = "i have a dream"

print(name.find("i"))

切片

name = "i have a dream"

print(name[name.find("have"):])

4.列表和元组

定义列表

list_1 = [1,2,3,4]

基本操作：

索引

list_1 = [1,2,3,4]

list_1.index(2)#取列表中的数据2的下标

插入

list_1 = [1,2,3,4]

list_1.insert(2,'new')#在索引下标为2的前面插入数据

追加

list_1 = [1,2,3,4]

list_1.append(5)

删除

list_1 = [1,2,3,4]

del list_1[2] #删除下标为2的数据

list_1.pop()#删除最后一个数据

list_1.remove(2)#删除指定数据

长度

list_1 = [1,2,3,4]

print(len(list_1))

切片

list_1 = [1,2,3,4] 

print(list_1[1:3]) #取下标1至下标3之间的数字，包括1，不包括3

print(list_1[1:-1]) #取下标1至下标-1之间的数字，包括1，不包括-1

print(list_1[0:3])#如果是从头开始取

print(list_1[:3])#如果是从头开始取，0可以忽略

print(list_1[3:])#如果想取最后一个，必须不能写-1，只能这么写

print(list_1[1::2]) #后面的2是代表，每隔一个元素，就取一个

拷贝（详见深浅拷贝）
排序&翻转

list_1 = [1,8,6,3,7,9]

list_1.sort() #无序到有序

print(list_1)

list_1.reverse()#将有序倒序

print(list_1)

定义元组

yuan = (1,2,3,4)

元组基本和列表相同都是储存一串数据，但是元组一经创建就不能再改变又叫只读列表。所以元组只存在两个方法，count()和index()。

字典

字典的数据类型是key - value的，而且key的值时唯一的，而且字典是无序的。

定义字典

player = {

        "西甲":"皇马",

        "英超":"曼连",

        "德甲":"拜仁"

    }

基本操作：

增加

player["意甲"] = "米兰"

修改

player["英超"] = "利物浦"

删除

piayer.pop("西甲")

del piayer["英超"]

player.popitem() #随机删除

查找

player.get("西甲")#获取

plaer["西甲"]#同上，但是当key值不存在时第一种方法不会报错

多级嵌套

player = {

        "西甲":{

            "皇马":["克里斯蒂亚.罗纳尔多","拉雷斯.贝尔","拉莫斯"],

            "巴萨":["莱昂.梅西","内马尔","苏亚雷斯"],

            "马竞":["托雷斯","格里兹曼"]

        },

        "英超":{

            "曼连":["维恩.鲁尼","伊布拉希莫维奇","博格巴"],

            "阿森纳":["桑切斯","拉姆塞","厄齐尔"],

            "曼城":["阿奎罗","斯特林","图雷"]

        },

        "德甲":{

            "拜仁":["里贝里","罗本","拉姆"],

            "多特":["罗伊斯","格策","香川真司"]

        }

    }

球员名单

循环

for key in player:

    print(key,player[key])

练习

程序: 三级菜单

要求:

打印联赛、球队、球员三级菜单
可返回上一级
可随时退出程序

import rosters,sys #调用sys模块 并从rosters文件中调用变量

T = 1 #设置一个全局变量来保证每次从循环跳出后能返回上一级的循环

while True:

    print("欢迎来到2016足球经理 在这里你将选择你中意的足球明星加入你的阵中！")

    for i in rosters.player: #显示联赛名单 供用户选择

        print(i)

    league = input("选择联赛：")

    if league in rosters.player:

        if T == 1:

            for tream in rosters.player[league]:  #显示队伍的名单

                print("****%s***"%tream)

            tream = input("b：返回上一级 \nq：退出游戏！\n选择球队： ")

            if tream == "b":

                break

            if tream == "q":

                sys.exit("退出游戏！") #退出整个系统

            if tream in rosters.player[league]:

                if T == 1:

                    for players in rosters.player[league][tream]: #显示球员的名单

                        print("****%s***" % players)

                    players = input("b：返回上一级 \nq：退出游戏：\n选择球员：")

                    if players == "b":

                        break

                    if players == "q":

                        sys.exit("退出游戏！")

                    if players in rosters.player[league][tream]:

                        f = open("roster","a",encoding="utf-8") #打开文件将选择的球员名字写入到文件中

                        f.write(players)

                        f.close()                               #关闭文件

                        print("球员%s已经加入你的阵容" %players)

                        choice = input("你是否要继续 b：返回上一级 q：退出游戏！")

                        if choice == "b":

                            pass

                        if choice == "q":

                            sys.exit("退出游戏！")

足球经理

集合

集合特性：
1、不同元素组成
2、无序
3、集合中元素必须是不可变类型

它的主要作用如下：

去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之前的交集、差集、并集等关系

基本操作：

去重

a = {1,2,3,4,4,5,5,6}

print(a)

添加

a = {1,2,3,4,4,5,5,6}

a.add(7)#每次只能添加一个值且添加的值

print(a)

删除

a = {1,2,3,4,4,5,5,6}

a.remove(8)#指定删除，当删除的值不存在时会报错

a.discard(8)#指定删除，当删除的值不存在时不会报错

a.pop()#随机删除

print(a)

清空

a = {1,2,3,4,4,5,5,6}

a.clear()

print(a)

集合支持一系列标准操作，包括并集、交集、差集和对称差集。

a = t | s          # t 和 s的并集  

b = t & s          # t 和 s的交集  

c = t – s          # 求差集（项在t中，但不在s中）  

d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）

基本操作：

交集

a = {1,2,3,4}

b = {3,4,5,6}

print(a.intersection(b)) #取出两个集合中相同的值等同于 a&b

并集

a = {1,2,3,4}

b = {3,4,5,6}

print(a.union(b)) #相同于 a|b

差集

a = {1,2,3,4}

b = {3,4,5,6}

print(a.difference(b)) #这是取a中不同于b中的值，相同于 a-b

对称差集

a = {1,2,3,4}

b = {3,4,5,6}

print(a.symmetric_difference(b)) #去掉两个都有的值，把对方没有的值取出

子集、父集

a = {1,2,3,4}

b = {3,4,5,6}

c = {2,3}

print(c.issubset(a)) #判断c是否是a的子集

print(a.issuperset(c)) #判断a是否是c的父集

更新

a = {1,2,3,4}

b = {3,4,5,6}

a.update(b)

print(a) #可更新多个值

不可变集合

元素一经创建，不可增加、删除和修改

a = frozenset({1,2,3,4})

b = {3,4,5,6}

a.update(b)

print(a) #a是不可变的集合所以更新值会报错 正确的输出应该是frozenset({1,2,3,4})

frozenset和set混合运算时，返回的值以左边的操作变量为准。

frozenset(a) | set(b)   的返回值就是frozenset，

set(a) | frozenset(b)  的返回值就是set

一些小小总结

可变不可变：

1、可变：列表，字典
2、不可变：字符串，数字，元组

访问顺序：

1、直接访问：数字
2、顺序访问：字符串，列表，元组
3、映射：字典