python第二课基本数据类型 - wing<>

简单结构：整数、浮点数、布尔值、字符串

多维结构：列表、元组、集合、字典

大概的数据类型有:

整数（int）:

表示整数，例如：

# 整形
x = 2
print('%s%s'%('整型:' , x) )

浮点数（float) :

表示带有小数点的数值，例如：

# 浮点型
y = 1.23
print('%s%s'%('浮点型:' , y) )

布尔值（bool）:

表示真（True）或假（False）的值，用于逻辑运算，例如：

# 布尔值
is_true = True
print('%s%s'%('布尔值:' , is_true) )

字符串（str）:

表示文本数据，可以使用单引号或双引号表示，例如：

# 字符串
text = "Welcome, Python!"
print('%s%s'%('字符串:' , text) )

列表（list）:

有序的可变容器，可以包含不同数据类型的元素，例如：

# 列表
colorlist = [99, 88, 'red']
print('%s%s'%('列表:' , colorlist) )

# 如何创建list列表
#1,创建空列表
l1 = []
print('%s%s'%('l1空列表:',l1))
#2,使用list()函数
l2 = list('I love world!')
print('%s%s'%('l2列表:',l2))
l3 = list([1,'gem',[{12,67},'我是子列表中的内容']])
print('%s%s'%('l3列表:',l3))

#列表操作，增删改查
#######新增
# 1,list新增元素,在列表末尾添加新元素。
l1.append('18班')
l1.append('苹果')
print('%s%s'%('l1空列表append新增元素:',l1))
# 2,extend()方法在列表末尾添加另一个列表中的所有元素，添加的东西可以是字典、元组、集合、字典
lx = [1,2,3,'你好','幸福']
l1.extend(lx)
print('%s%s'%('l1列表用extend新增元素:',l1))
# 使用insert()方法，将元素插入到列表指定位置 例如:l1.insert(index,obj)  index就是索引的意思，插入到第几个位置，从0开始数
listInsert = [1,2,3,4,5,6]
listInsert.insert(1,'我插入到索引1指定位置')
print('%s%s'%('Insert插入列表:',listInsert))

######## 列表删除
#1,del可以删除列表中指定元素的位置,根据索引删除的，例如删除索引为1的'索引1指定位置'
delList = [1,'索引1指定位置',2,3,4,5,6]
del delList[1]
print('%s%s'%('del删除列表指定元素:',delList))

#2，remove()方法也可以删除list中的某个元素,如果移除目标中有多个要移除的元素，那么只会移除匹配到的第一个
removeList =  ['上海','北京','深圳','上海']
removeList.remove('上海')
print('%s%s'%('remove删除列表指定元素:',removeList))

#3,使用pop()方法删除list中的元素 例如:list.pop(0),这和是删除列表中第一个元素,对应的索引是0
popList = ['上海','北京','深圳','上海']
popList.pop(0)
print('%s%s'%('pop删除列表指定元素:',popList))

###### 列表的修改
editList =['1班','2班','香蕉','橘子']
editList[0]='把1班改为你好'
print('%s%s'%('修改列表指定元素:',editList))


######列表元素的访问
coffee =  ['黑咖啡','奥利奥咖啡','热拿铁','冰美式']

# 1,使用in操作符,i代表的是对应的数值
for i in coffee:
    print(i,end= ' ')

# 2, 使用range()函数
# 求coffee列表的长度,这个可以用索引来获取对象，i代表的是索引
length =len(coffee)
for i in range(length):
    print(i,end= ' ')
    print(coffee[i],end= ' ')
    
##3，使用iter()函数
for i in iter(coffee):
    print(i,end= ' ')
    
#4，使用enumerate()函数 遍历列表元素及下标
for i in enumerate(coffee):
    print('%s%s'%('我是enumerate的下标:',i[0]))
    print(i,end= ' ')

View Code

元组（tuple）:

和list类似不同之处在于，有序的不可变容器，例如：

#  元组
my_tuple = (3, 2, 'orange')
print('%s%s'%('元组:' , my_tuple) )

######tuple学习
#使用tuple函数创建元组
cre_tuple=tuple(('a','b','c'))
print(cre_tuple)
##单个元素
cre_tuple1=(20,'night','warmDay','kiki','link','pink')

###元组的查询
#索引访问
print(cre_tuple1[0])
print(cre_tuple1[-1])
print(cre_tuple1[2])
#切片访问使用切片访问元组的格式为
# tuple_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。
print(cre_tuple1[0:5:1])

# for循环遍历元组
for i in cre_tuple1:
    print(i)

###修改元组(元组不可变),可以转换为列表，修改列表后再转换为元组
fruit_tuple =('番茄','香蕉','苹果','梨子')
fruit_list=list(fruit_tuple)
fruit_list[1]='banana'
fruit_tuple = tuple(fruit_list)
print(fruit_tuple)

###元组之间的合并、复制
#合并
x=(1,2,3)
y=(4,5,6)
print(x+y)
#复制
print(x * 5)

###删除元组,元组是不可变的，里面的单个元素无法删除和修改，但是可以删除整个元组
del_tuple=('x','y','z','c','v')
print(del_tuple)
del del_tuple
print(del_tuple)

View Code

集合（set）:

无序的可变容器，不允许重复元素，例如：

# 集合
my_set = {1, 2, 3}
print('%s%s'%('集合:' , my_set) )

####集合是个无序、不重复的元素序列
#创建集合
#1,花括号集合
fruits_set={'apple','banana','orange','potato'}
print('%s%s'%('fruits_set:' , fruits_set) )
#2,使用set()函数创建
set2=set([1,2,3])
print('%s%s'%('set2:' , set2) )
#3，创建空集合
set3=set()
print('%s%s'%('set3:' , set3) )
##增加元素
#添加单个元素
set3.add('老鹰')
print('%s%s'%('set3添加一个元素:' , set3) )
#添加多个元素
set3.update(['小鸡','狐狸','大灰狼'])
print('%s%s'%('set3添加多个元素:' , set3) )

##删除元素
print('%s%s'%('fruits_set:' , fruits_set) )
# remove(删除指定元素),元素不存在时抛出KeyError
fruits_set.remove('apple')
print('%s%s'%('fruits_set,用remove删除' , fruits_set) )
# discard删除指定元素,元素不存在时不报错
fruits_set.discard('potato')
fruits_set.discard('1')
print('%s%s'%('fruits_set，用discard删除' , fruits_set) )
#pop()随机删除一个元素并返回
fruits_set.pop()
print('%s%s'%('fruits_set，用pop随机删除一个还剩' , fruits_set) )

#clear()清空集合
fruits_set.clear()
print('%s%s'%('fruits_set，用clear清空集合' , fruits_set) )

##集合运算,比如并集、交集、差集、对称差集
#1，并集,两个集合加起来
A={1,2,3}
B={3,4,5}
#下面两个并集效果一样的，只是写法不一样
print(A | B) 
print(A.union(B))
#2,交集,就是相同的部分
print(A & B)
print(A.intersection(B))
#3, 差集,存在于A集合但不存在于B集合的所有元素，数字3在集合b中，所以不显示
print(A - B)             # 输出: {1, 2}
print(A.difference(B))   # 同上
# 4,对称差集,两个集合中不重复，不共有的数字集
print(A^B)
print(A.symmetric_difference(B))

View Code

字典（dict）:

无序的键值对集合，例如：

my_dict = {'name': 'Jay', 'age': 35}
print('%s%s'%('字典:' , my_dict) )

####字典的特性：1,字典是无序的只能通过key键来获取值。2,键必须是唯一不可变的数据类型，让比如数字、字符串、元组等。列表不可作为键
#### 值可以是任意类型的对象
#字典查询
scores_dict={'语文':105,'数学':140,'英语':120}
#通过键key->'语文'获得对应的分数105
print(scores_dict['语文'])

#字典是新增
#通过key添加key-value键值对
scores_dict['物理']=97
print('%s%s'%('scores_dict，用key-value新增字典' , scores_dict) )

# 字典键值对删除 通过del关键字删除
del scores_dict['语文']
print('%s%s'%('scores_dict，用del删除字典' , scores_dict) )

# 修改字典 ,通过key修改value,数学14改成150
scores_dict['数学']=150
print('%s%s'%('scores_dict，用键修改字典数值，140->150' , scores_dict) )

View Code

复数（complex）:

包含实部和虚部的数值，例如：

# 复数
z = 4 + 4j
print('%s%s'%('复数:' , z) )

字节串（bytes）:

以字节为单位的不可变序列，例如：

# 字节串
b = b'python'
print('%s%s'%('字节串:' , b) )

字节数组（bytearray) :

以字节为单位的可变序列，例如：

# 字节数组
ba = bytearray(b'python')
print('%s%s'%('字节数组:' , ba) )

课外小游戏,小恐龙

import pygame
#  pip install pygame -i https://pypi.tuna.tsinghua.edu.cn/simple/
'''-------------------------------定义一个小恐龙的类-------------------------------'''
class Dragon:
    #实例化的时候需要输入创建的游戏窗口对象
    def __init__(self, Screen):
        #小恐龙的默认参数
        self.screen = Screen
        self.rectangle = pygame.Rect(50, 210, 40, 45)    #小恐龙的边框,预先设计好就不需要移动到地上
        self.status = True #两种状态对应两个图片
        #定义小恐龙的两种状态(读取图片放在列表里)
        self.StatusPicture = [
            pygame.image.load('./picture/dragon1.png'),
            pygame.image.load('./picture/dragon2.png')
        ]
        self.jump_speed = 0  #小恐龙的跳跃速度，当为正的时候上升，为负的时候下降
        self.alive = True    #生命状态
        self.jump_flag = False   #跳跃标志，判断小恐龙是否跳跃
        self.count = 0

    #更新小恐龙的状态
    def update(self):
        #如果当前没有检测到跳跃且小恐龙在地上,轮流显示图片
        if self.jump_flag == False and self.rectangle[1] == 210:
            if self.count % 15 == 0:    #控制小恐龙踏步速度
                self.status = not self.status
            #轮流显示图片，这样可以造成小恐龙在跑的现象
            if self.status:
                screen.blit(self.StatusPicture[0], self.rectangle)
            else:
                screen.blit(self.StatusPicture[1], self.rectangle)
            self.count += 1
            self.count %= 10000  #防止溢出

        #如果检测到按下跳跃并且小恐龙在地上那就判定为有效跳跃
        if self.jump_flag and self.rectangle[1] == 210:
            self.jump_speed = 15 #将上升速度调为15

        #如果小恐龙的跳跃速度不为0，或者当前在空中，说明正在跳跃周期
        if self.jump_speed != 0 or self.rectangle[1] != 210:
            self.rectangle[1] -= self.jump_speed   #将小恐龙框移动
            self.jump_speed -= 1 #将速度降低，效果为上升越来越慢，下降越来越快
            if self.rectangle[1] >= 210:    #防止将小恐龙移动到地下
                #落地后恢复默认值等待下次跳跃
                self.Y_axis = 210
                self.jump_speed = 0
                self.jump_flag = False
            #如果在空中那就显示两个图片，效果就是两个脚都伸直（没有太大意义）
            self.screen.blit(self.StatusPicture[0], self.rectangle)
            self.screen.blit(self.StatusPicture[1], self.rectangle)   

'''-------------------------------定义一个地图的类-------------------------------'''
class Map:
    #实例化的时候需要输入创建的游戏窗口对象
    def __init__(self, Screen):
        self.screen = Screen
        self.speed = 3  #初始速度（像素）
        self.background_1 = pygame.image.load('./picture/background1.png')  # 加载图片
        self.background_2 = pygame.image.load('./picture/background2.png')
        self.background_rectangle_1 = self.background_1.get_rect()    # 获取图片大小的矩形区域
        self.background_rectangle_2 = self.background_2.get_rect()
        self.background_rectangle_2[0] = self.background_rectangle_1.right

    def update(self):
        #移动框
        self.background_rectangle_1 = self.background_rectangle_1.move(-self.speed, 0)
        self.background_rectangle_2 = self.background_rectangle_2.move(-self.speed, 0)

        if self.background_rectangle_1.right < 0:   #判断第一个背景框如果移动到了窗口外面
            self.background_rectangle_1[0] = self.background_rectangle_2.right  #将第一个背景框移动到第二个背景框后面，形成循环
        if self.background_rectangle_2.right < 0:   #和上面同理，最终实现的效果就是两个图片排着队从窗口前划过
            self.background_rectangle_2[0] = self.background_rectangle_1.right

        #将图片放到框里面
        self.screen.blit(self.background_1, self.background_rectangle_1)
        self.screen.blit(self.background_2, self.background_rectangle_2)

#主程序
if __name__ == "__main__":
    "-------------------------------初始化部分-------------------------------"
    pygame.init()  # 初始化pygame
    pygame.display.set_caption('Dino')  #设置窗口标题
    screen = pygame.display.set_mode([734, 286])  # 创建并显示窗口，设置这个大小是因为一张背景图就是这么大
    clock = pygame.time.Clock() #创建一个时间对象用于控制游戏运作的快慢

    map = Map(screen)     #创建地图实例
    dragon = Dragon(screen)   #创建小恐龙实例
    score = 0   #设置初始分数

    "-------------------------------主循环部分-------------------------------"
    running = True
    while running:  # 死循环确保窗口一直显示
        clock.tick(60)      #越大越快
        for event in pygame.event.get():  # 遍历所有事件
            if event.type == pygame.QUIT:  # 如果程序发现单击关闭窗口按钮
                running = False
            if event.type == pygame.KEYDOWN or event.type == pygame.MOUSEBUTTONDOWN:
                dragon.jump_flag = True

        map.update()    #更新地图元素框的位置
        dragon.update()     #更新小恐龙元素框的位置

        #这部分暂时测试用 现在背景的移动速度和时间成正比
        score += 1
        if score % 100 == 0:
            map.speed += 0.5

        pygame.display.flip()  # 更新全部显示

    pygame.quit()

对应的图片:

-----------------------

背景1

***********背景2

***********龙1

************龙2

************

发表于 2025-03-28 10:42 wing<> 阅读(232) 评论(0) 收藏举报