Python学习笔记--数据容器

已于 2023-07-16 16:42:39 修改
阅读量1.1k 收藏 6
点赞数 1
分类专栏： Python 文章标签： 学习 python 开发语言 算法 笔记
于 2023-04-12 15:39:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63654706/article/details/130099585
版权

文章末尾进行了详细的扩展

（一） 数据容器入门


1. 数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素。每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

2.. 种类：list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）

（二） 数据容器：list（列表）


1. 定义


（1） 基本语法：

# 字面量

[元素1 ，元素2 ，元素3，……]

# 定义变量

变量名称 = [元素1 ，元素2 ，元素3，……]

# 定义空列表

变量名称 = []

变量名称 = list（）

（2） 元素：列表中的每个数据

 列表可以一次存储多个数据，且可以为不同类型，支持嵌套

2. 列表的下标索引


（1） 类型：正向：从前向后，从0开始，依次递增

                        反向：从后向前，从-1开始，依次递减

（2） 使用：

列表[下标]

 下标超出范围，则无法取出元素，并且会报错

3. 列表的常用操作（方法）


* 函数：封装的代码单元，可提供特定功能。

  如将函数定义为class（类）的成员，则称函数为方法。

编号关键字使用方法作用
1index列表.index（元素）查找指定元素在列表中的下标，找不到则报错ValueError
2lenlen（列表）统计容器中有多少元素
3count列表.count（元素）统计此元素在列表中出现的次数
4deldel 列表[下标]删除列表指定的下标元素
5pop列表.pop(下标)删除列表指定的下标元素，不写下标默认最后一个元素
6remove列表.remove（元素）从前向后，删除此元素的第一个匹配项
7append列表.append（元素）向列表中追加一个元素
8extend列表.extend（容器）将数据容器中的内容依次取出，追加到列表尾部
9insert列表.insert（下标，元素）在指定下标处，插入指定的元素
10clear

列表.clear（）

清空列表
11.sortlist.sort()对列表中的元素进行排序。
12.reverselist.reverse()倒排列表中的元素。

4. 列表的特点

  • 可容纳多个元素
  • 可容纳不同类型的元素
  • 数据是有序存储的
  • 允许重复数据存在
  • 可进行增删查改.
age = [21, 25, 21, 23, 22, 20]

age.append(31)
print(age)

age.extend([29, 33, 30])
print(age)

x = age[0]
y = age[-1]

print(x, y)

a = age.index(31)
print(a)

练习2：

#
a = [66.25, 333, 333, 1, 1234.5]
print(a.count(333), a.count(66.25), a.count('x'))#统计此元素在列表中出现的次数
#
a.insert(2, -1)#在指定下标处，插入指定的元素
a.append(333)#向列表中追加一个元素
print(a)
#
a.index(333)#返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
print(a.index(333))
#
a.remove(333)#从前向后，删除此元素的第一个匹配项
print(a)
#
a.reverse()	#倒排列表中的元素。
print(a)
#
a.sort()#对列表中的元素进行排序。
print(a)

（三） list（列表）的遍历

遍历：将容器内的元素依次取出，并处理

1.  使用while遍历

     可以指定循环条件，自行控制
     可以通过条件控制做到无限循环
     适用于任何想要循环的场景


2. 使用for遍历


     不可以指定循环条件，只可以一个个从容器内取出数据
     理论上不可以无限循环，因为被遍历的容器容量不是无限的
     适用于遍历数据容器的场景或简单的固定次数循环场景
练习：

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
l1 = list()
l2 = list()
i = 0

# 取出偶数
while i < len(L):
    if L[i] % 2 == 0:
        l1 . append(L[i])
        i = i + 1
    else:
        i = i + 1
print(f"通过while循环，从列表：{L}，中取出偶数，组成新列表{l1}")


for j in L:
    if j % 2 == 0:
        l2 . append(j)
print(f"通过for循环，从列表：{L}，中取出偶数，组成新列表{l2}")

（四） 数据容器：tuple（元组）

* 元组一旦定义，不可进行修改

1. 元组的定义


（1） 基本语法：

# 字面量

（元素1 ，元素2 ，元素3，……）

# 定义变量

变量名称 =（元素1 ，元素2 ，元素3，……）

# 定义空列表

变量名称 = （）

变量名称 =tuple（）

 元组即使只含有一个数据，这个数据后也要添加，也可进行嵌套

2. 元组的操作（方法） 
 

编号关键字使用方法作用
1indexindex（）查找指定数据在元组中的下标，找不到则报错
2lenlen（元组）统计元组内有多少元素
3countcount（）

统计某个数据在元组中出现的次数

！ 不可修改元组内容，否则直接报错

！ 可修改元组内list的内容

！ 不可以替换元组内list为其他list或其他类型

3. 元组的特点

  • 可容纳多个元素
  • 可容纳不同类型的元素
  • 数据是有序存储的
  • 允许重复数据存在
  • 可进行增删查改
  • 可进行循环
  • 不可修改

练习：

T = ('周杰伦', 11, ['football', 'music'])

a = T.index(11)
n = T[0]
print(a,n)

del T[2][0]
T[2].append('coding')

print(T)

（五） 数据容器：str（字符串）


1. 字符串


字符的容器，一个字符串可以存放任意数量的字符。

2. 字符串的下标（索引）


从前向后，下标从0开始
从后向前，下标从-1开始
！ 字符串是一个无法修改的数据容器

！ 如果要修改，则会得到一个新的字符串，旧的字符串是无法修改的

3. 字符串的常用操作

编号关键字使用方法作用
1字符串[下标]根据下标索引取出特定位置字符
2index字符串.index（字符串）查找给定字符的第一个匹配项的下标
3replace字符串.replace（字符串1，字符串2）

将字符串内的全部字符串1，替换为字符串2

！不会改变原字符串，而是得到一个新的字符串

4split字符串.split（字符串）

按照给定字符串，对字符串进行分割

！不会改变原字符串，而是得到一个新的列表

5strip

字符串.strip（）

字符串.strip（字符串）

移除首尾的空格和换行符或指定字符串
6

count

字符串.count（字符串）统计字符串内某字符串的出现次数
7lenlen（字符串）统计字符串的字符个数

4. 字符串的特点

  • 只可以存储字符串
  • 长度任意
  • 支持下标索引
  • 允许重复的字符串出现
  • 不可以修改
  • 支持循环

练习：

S = "itheima itcast boxuegu"

n = S.count("it")
print(f"字符串{S}中有{n}个it字符")

S1 = S.replace(" ", "|")
print(f"字符串{S}，被替换空格后，结果{S1}")

L = S1.split("|")
print(f"字符串{S}，按照“|”分割后，得到{L}")

（七） 数据容器：set（集合）


1. 集合的基本语法


# 定义集合字面量

（元素，元素，……，元素）

# 定义集合变量

变量名称 = {元素，元素，……，元素}

# 定义空集合

变量名称 = set（）

！ 去重且无序，无法保证顺序与创建的时候一致

！ 不支持：下标索引访问，因此不支持while循环

补充：

定义：

列表[]         可修改、支持重复元素且有序

元组（）    不可修改、支持重复元素且有序

字符串“”     不可修改、支持重复元素且有序

集合{}         可修改、不支持重复元素、无序

2. 集合的常用功能
 

编号关键字使用方法作用
1add集合.add（元素）集合内添加一个元素
2remove集合.remove（元素）移除集合内指定的元素
3pop集合.pop（）从集合中随机取出一个元素
4clear集合.clear（）将集合清空
5difference集合1.difference（集合2）

得到一个新集合，内含2个集合的差集

原有的2个集合内容不变

6update集合1.difference_update（集合2）

在集合1中，删除集合2中存在的元素

集合1被修改，集合2不变

7union集合1.union（集合2）得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变
8lenlen（集合）得到一个整数，记录了集合的元素数量

3. 集合的特点

  • 可以容纳多个数据
  • 可以容纳不同类型的数据（混装）
  • 数据是无序存储的（不支持下标存储）
  • 不允许重复数据存在
  • 可以修改
  • 支持for循环，不支持while循环

练习：

my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']
 
S = set()
for i in my_list:
    S.add(i)
 
print(f"有列表：{my_list}")
print(f"存入集合后结果：{S}")

（八） 数据容器：dict（字典、映射）


1. 字典的基本语法


# 定义字典字面量

{key：value，key：value，……，key：value}

# 定义字面变量

my_dict = {key：value，key：value，……，key：value}

# 定义空字典

my_dict = {}

my_dict = dict{}

！ 每个元素均为键值对，key和value可以为任意类型数据（key不可为字典）

！ key不可重复，重复会对原有数据覆盖

！ 不可以使用下标索引，但可通过key值取得对应的value，不可使用while循环

！ 字典可嵌套

2. 字典的常用操作
 

编号关键字使用方法作用
1字典[Key]获取指定Key对应的Value值
2字典[Key] = Value添加或更新键值对
3pop字典.pop（Key）取出Key对应的Value并在字典内删除此Key的键值对
4clear字典.clear（）清空字典
5keys字典.keys（）获取字典的全部Key，可用于for循环遍历字典
6lenlen（字典）计算字典内的元素数量

3. 字典的特点

  • 可以容纳多个数据
  • 可以容纳不同类型的数据（混装）
  • 不支持下标索引
  • 可以修改
  • 支持for循环，不支持while循环

练习：

D = {
    "王力鸿":{"部门":"科技部","工资":3000,"级别":1},
    "周婕纶":{"部门":"市场部","工资":5000,"级别":2},
    "凌俊杰":{"部门":"市场部","工资":7000,"级别":3},
    "张雪有":{"部门":"科技部","工资":4000,"级别":1},
    "牛德华":{"部门":"市场部","工资":6000,"级别":2}
}
keys = D.keys()

print(D)

for key in keys:
    if D[key]["级别"] == 1:
        D[key]["工资"] = D[key]["工资"] + 1000

print(D)

 扩展：数据容器的对比总结

列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意任意仅字符任意

Key：除字典外任意类型

Value：任意类型

下标索引✓✓✓××
重复元素✓✓✓××
可修改性✓××✓✓
数据有序✓✓×××
使用场景可修改、可重复的一批数据的记录不可修改、可重复的一批数据的记录一串字符的记录不可重复的数据记录以Key检索Value的数据记录

（九） 数据容器的通用操作

序号功能描述
1for循环遍历容器（字典是遍历key）
2max（）容器内最大元素
3min（）容器内最小元素
4len（）容器内元素个数
5list（）转换为列表
6tuple（）转换为元组
7str（）转换为字符串
8set（）转换为集合
9sorted（序列，[reverse = True]）

排序，得到一个排好序的列表

reverse = True表示“降序”

（十）综合案例

练习题1：

# 幸运数字6：
# 1. 输入任意数字，如数字8，生成nums列表，元素值为1-8，
#  2. 从中选取幸运数字（能被6整除）移动到新列表lucky
# 3. 打印nums和lucky

n = int(input("请输入您所想的数字："))
i = 1
j = 0
nums = list()
lucky = list()
print(n)

while i <= n:
    nums.append(i)
    i = i + 1

print(f"nums列表为：{nums}")

for j in nums:
    if j % 6 == 0:
        lucky.append(j)
    j = j + 1

print(f"lucky列表为：{lucky}")

结果1：

结果2： 

 练习题2：

# 列表嵌套：
# 3个教室[[],[],[]]
# 8名讲师['A','B','C','D','E','F','G','H']
# 随机分配
import random
 
classroom = [[],[],[]]
teacher = ['A','B','C','D','E','F','G','H']
 
j = random.randint(0,2)
 
for i in teacher:
    classroom[j].append(i)
    j = random.randint(0,2)
 
print(f"分配后为：{classroom}")

一、基础知识

可变序列：目前包括字典、列表

不可变序列：目前包括整数，字符串

区别在于可变序列可以进行增、删、查、改操作，而不可变序列不可以进行

二、 字典的组成及原理

字典是由键值对组成的，字典是无序的排列方式，他不是根据你输入键的前后顺序来存储他，而是根据键的哈希值来存储

也是由于这个原因，字典的键必须是一个不可变序列，而且键不可以重复

语法格式如此：字典名={键：值，键：值，…}

字典的实现原理：

他是先由哈希函数计算键从而得到不同键的索引,然后根据键的索引排序键，键中保存的是值的地址，从而达到引用键而找到值的效果

字典特点：

1.字典中键值对是一一对应的，其中，键是不可以重复的，而值是可以重复的

2.字典中的键值对是无序的

3.字典是一种用空间换时间的数据结构

4.字典的键必须是不可变对象

三、字典的创建方式

字典的创建方式总共有两种：

1.通过{}创建字典
score={'tom':85,'jack':92,'sam':'pass'}
print(score)                        #输出{'tom': 85, 'jack': 92, 'sam': 'pass'}

print(type(score))                  #输出<class 'dict'>
2.通过内置函数dict()创建字典

在()里面写入键值对，与{}不同的是，这种创建方式为键=值，而不是键：值，这点需要注意

student=dict(tom=85,jack=92,sam='pass')
print(student)                      #输出{'tom': 85, 'jack': 92, 'sam': 'pass'}
print(type(student))
3.创建一个空列表
empty={}                            #输出{}
print(empty)

empty1=dict()
print(empty1)

四、字典元素的获取

字典元素的获取有两种方法：

1.使用[]获取，[]里面是键值
print(score['tom'])             #输出58

#print(score['alice'])               #如果查找不到，就会报错：KeyError: 'alice'
2.使用get()方法获取
score={'tom':58,'linda':62,'jack':98}
print(score.get('tom'))             #输出58

print(score.get('alice'))           #如果查找不到就会输出：None，这个none是可以代替的，在键后面加入替代的值，找不到就会输出替代的值

print(score.get('alice',56))        #输出56，如果查找不到就会默认输出键后面的值

五、字典元素的增删改操作

5.1字典元素的修改
dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}

print(dict)             #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}

dict['tom']=100

print(dict)             #输出{'tom': 100, 'jack': 59, 'marry': 53, '刘桂香': 77}
5.2 字典元素的删除：
dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}

print(dict)             #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}

del dict['tom']             #删除会删除整个键值对

print(dict)             #输出{'jack': 59, 'marry': 53, '刘桂香': 77}
5.3 字典元素的增加
dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}

print(dict)

dict['alice']=5666

print(dict)                 #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77, 'alice': 5666}
5.4 字典元素的清空
dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}

print(dict)                 #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}

dict.clear()

print(dict)                 #输出{}

六、获取字典视图

实际上就是获取字典里面所有的键，所有的值，以及所有的键值对

这三种东西的获取方法各有不同，虽然方法各不一样，但是操作原理，用法都是一样的

6.1 获取所有的键

keys()函数

score={'tom':58,'linda':62,'jack':98}

a=score.keys()
print(a)            #输出dict_keys(['tom', 'linda', 'jack'])
#可以将输出的键进行列表化，获得键的列表

print(list(a))      #输出['tom', 'linda', 'jack']
6.2 获取所有的值

values()函数

score={'tom':58,'linda':62,'jack':98}
b=score.values()
print(b)                # 输出dict_values([58, 62, 98])
print(list(b))          #输出[58, 62, 98]
6.3 获取所有的键值对

items()函数

score={'tom':58,'linda':62,'jack':98}

print(score.items())        #输出dict_items([('tom', 58), ('linda', 62), ('jack', 98)])
print(list(score.items()))          #输出[('tom', 58), ('linda', 62), ('jack', 98)]

七、字典元素的遍历

使用for in循环进行遍历
score={'tom':58,'linda':62,'jack':98}

for i in score:             #这里的i表示的是键，如果要获取字典的值，就需要使用[]获取或者get函数获取
    print(i,score[i],score.get(i))

八、字典生成式

实际上和列表生成式差不太多，多使用了一个内置函数zip，而且由于字典是由键值对组成的，所以需要两个可迭代对象

zip函数组成字典生成式里面，如果键的个数和值得个数不相同时，以小的为准

items=['books','fruits','papers']

prices=[98,56,233]

a={i:j for i,j in zip(items,prices)}
print(a)

prices1=[978,5,5,6451,1]            #当键和值的个数不一样的时候，以短的为准

b={m:n for m,n in zip(items,prices1)}
print(b)

九、元组

9.1 什么是元组？
9.2 元组的创建 
9.3 如果元组中只有一个元素，逗号不能省 
t1=('python','world',23)
print(t1)
print(id(t1))
print(type(t1))
# ('python', 'world', 23)
# 1882095097664
# <class 'tuple'>
t2=tuple(('python','world',25))
print(t2)
print(id(t2))
print(type(t2))
# ('python', 'world', 25)
# 1882095097856
# <class 'tuple'>
t3='python','world',23
print(t3)
print(id(t3))
print(type(t3))
# ('python', 'world', 23)
# 1882095097664
# <class 'tuple'>
t=('python',)
print(t)
print(type(t))
# ('python',)
# <class 'tuple'>
t=('python')
print(t)
print(type(t))
# python
# <class 'str'>
 
#空元组创建方式
t=()
t1=tuple()
9.4 为什么元组是不可变序列
t=(10,[20,30],9)
print(t)
# t[1]=100 TypeError: 'tuple' object does not support item assignment
t[1].append(100)
print(t)
 
# (10, [20, 30], 9)
# (10, [20, 30, 100], 9)
 9.5 元组的遍历

t=tuple(('python','world',25))
#使用索引获取元组,容易越界
print(t[0])
print(t[1])
print(t[2])
#遍历元组获取元组，不需要知道元祖个数
for item in t:
    print(item)

十、集合

什么是集合

 集合的创建

 集合中元素不允许重复；集合中元素无序

s={23,25,43,32,23,123,43,34,23}
print(s)
print(type(s))
# {32, 34, 23, 123, 25, 43}
# <class 'set'>
s=set(range(6))
print(s,type(s))
# {0, 1, 2, 3, 4, 5} <class 'set'>
print(set([3,4,5,6,5]))
# {3, 4, 5, 6}列表转集合
print(set((3,4,5,3,2,34,3,32,2)))
# {32, 34, 2, 3, 4, 5}元组转集合，集合中元素无序
print(set('PYTHON'))
# {'Y', 'H', 'P', 'O', 'N', 'T'} 字符串序列转集合
print(set({1,2,3,4,2,3,4,5,124}))
{1, 2, 3, 4, 5, 124}
 
#不能用花括号定义空集合
print(type({}),{})
print(type(set()),set())
# <class 'dict'> {}
# <class 'set'> set()
集合的相关操作

s={10,20,30,40,50}
 
print(10 in s)
print(100 in s)
 
s.add(100)
print(s)
s.update({200,400,300})
print(s)
s.update([500,600])
print(s)
s.update((700,800))
print(s)
# {50, 20, 100, 40, 10, 30}
# {100, 40, 200, 10, 300, 400, 50, 20, 30}
# {100, 40, 200, 10, 300, 400, 50, 20, 500, 600, 30}
# {800, 100, 40, 200, 10, 300, 400, 50, 20, 500, 600, 700, 30}
s.remove(100)
print(s)
# s.remove(900) KeyError: 900
s.discard(900)
print(s)
s.pop()
print(s)
# s.pop(400) TypeError: set.pop() takes no arguments (1 given) 函数pop()
# {800, 40, 200, 10, 300, 400, 50, 20, 500, 600, 700, 30}
# {800, 40, 200, 10, 300, 400, 50, 20, 500, 600, 700, 30}
# {40, 200, 10, 300, 400, 50, 20, 500, 600, 700, 30}
s.clear()
print(s)
# set()

 集合间的关系

s={10,20,30,40}
s1={20,10,40,30}
print(s1==s)
#True
 
s2={10,30}
s3={30,50}
print(s2.issubset(s))
print(s3.issubset(s))
# True
# False
print(s.issuperset(s2))
print(s.issuperset(s3))
# True
# False
 
s4={60,70,80}
print(s.isdisjoint(s1))
print(s.isdisjoint(s2))
print(s.isdisjoint(s4))
# False
# False
# True

 集合的数据操作

#交集:intersection()  或  &
s1={10,20,30}
s2={23,30,20}
print(s1.intersection(s2))
print(s1 & s2)
# {20, 30}
# {20, 30}
 
#并集:union()   或  |
print(s1.union(s2))
print(s1 | s2)
# {20, 23, 10, 30}
# {20, 23, 10, 30}
 
#差集：difference()   或  -
s1={10,20,30,40}
s2={20,30,50}
print(s1.difference(s2))
print(s1-s2)
# {40, 10}
# {40, 10}
 
#对称差集：symmetric_difference()   或   ^
s1={10,20,30,40}
s2={20,30,50}
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
# {40, 10, 50}
# {40, 10, 50}

集合生成式 

#列表生成式
lst=[i*i for i in range(6)]
print(lst,type(lst))
#集合生成式
s={i for i in range(6)}
print(s,type(s))
# [0, 1, 4, 9, 16, 25] <class 'list'>
# {0, 1, 2, 3, 4, 5} <class 'set'>

列表、字典、元组、集合总结 

 

追着太阳跑哈
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python-第六天 Python数据容器
qq_41050821的博客
02-15 1460
字面量 [ 元素 1 , 元素 2 , 元素 3 , 元素 4 , . . . ] # 定义变量 变量名称 = [ 元素 1 , 元素 2 , 元素 3 , 元素 4 , . . . ] # 定义空列表 变量名称 = [ ] 变量名称 = list()列表内的每一个数据，称之为元素以[]作为标识列表内每一个元素之间用逗号隔开注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套my_list1 } 列表的类型为: {my_list2 } 列表的类型为: {
Python入门笔记-最详细的总结
09-13
【Python入门笔记】这篇笔记是基于B站上的一套Python全栈开发教程的前133页内容编写的，旨在帮助初学者系统地学习Python编程。笔记内容包括实操代码、重点知识截图以及详细的注释，确保学习者能够清晰理解和实践每一...
练习案例:元组的基本操作
yangling8702的博客
08-23 1157
对其进行 查询其年龄所在的下标位置 查询学生的姓名 删除学生爱好中的football 增加爱好：coding到爱好list内。定义一个元组，内容是：（'周杰轮', 11, ['football', 'music']），记录的是一个学生的信息（姓名、年龄、爱好） 请通过元组的功能（方法），
【python】Python基础语法详细教程以及案例教学之数据容器（上）（列表、元组）
m0_63501513的博客
07-29 142
Python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。数据容器根据特点的不同，如:是否支持重复元素是否可以修改是否有序，等列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）为什么需要列表？有一个人的姓名(TOM) 怎么在程序中存储?答：字符串变量如果一个班级100位学生，每个人的姓名都要存储，应该如何书写程序?声明100个变量吗？
幸运数字6：输入任意数字，如数字8，生成nums列表，元素值为1~8，从中选取幸运数字(能够被6整除)移动到新列表lucky，打印nums与lucky。
最新发布
w3517的博客
12-16 891
print(f"您输入的数字如下：\n{nums}")b = input("请输入是否结束？print("输入有误结束输入")print(f"幸运数字是：\n{lucky}")print("请继续输入：")
Python---练习：求幸运数字6
qq_42755734的博客
11-10 1420
涉及定义空列表，然后用for循环获取数字，再用if判断哪个数字符合，之后用remove删除、append追加，给列表中填充数据。
python入门：第五天
weixin_45818577的博客
10-03 494
python入门：元组和列表
python-学习笔记
05-22
Python是一种高级编程语言，以其简洁明了的...了解并掌握这些基础知识是Python学习的第一步。随着学习的深入，你将接触到更复杂的概念，如控制流、函数、类、模块和异常处理等，这些都是构建复杂Python应用程序的基础。
python学习笔记
12-17
在Python学习笔记中，我们主要探讨以下几个核心知识点： 1. **数据类型与数据结构** Python支持多种数据类型，包括基本的整型、浮点型、字符串等。其中，数据结构是Python的一大特色，特别是容器类型。容器可以...
python基础教程-学习笔记充电时刻-模块共13页.p
10-30
理解这些类型及其操作是Python学习的基础。 4. **控制结构（Control Structures）**：包括条件语句（如if-else）用于决定代码的执行路径，循环（如for和while）用于重复执行某段代码，以及异常处理（try-except）来...
《Python编程从入门到实践》-学习笔记-第二章（变量和简单数据类型）
12-21
- 变量是存储数据的容器，Python会跟踪其最新的值。例如，`message = "Hello Python world!"` 创建了一个名为`message`的变量，并将其值设置为字符串。 - 变量命名规则：变量名只能包含字母、数字和下划线，且不能...
010619-幸运数字6
木丂的博客
07-22 514
从中选取幸运数字(能够被6整除)移动到新列表lucky，打印nums与lucky。输入任意数字，如数字8，生成nums列表，元素值为1~8，
【Python基础】篇七之数据容器-元组
qq_61798306的博客
02-23 924
变量名称=(元素，元素，元素)注：元组定义使用小括号，数据可以是不同类型元组只有一个数据时，这个数据后面要添加逗号，eg：t1=(1,)元组也支持嵌套，和列表一样特别的，元组不可修改，否则会报错t1[0]=2运行结果：可以修改元组内list的内容（修改，增加，删除）print(t1)运行结果：6.不可以替换list为其它list或其它类型print(t1)
for...of和for...in
rosies的博客
05-27 572
for…of和for…in for...in循环读取键名(index)，for...of循环读取键值；for...of循环调用遍历器接口，数组的遍历器接口只返回具有数字索引的属性，for…in不同 for...in环可以使用的范围包括数组、某些类似数组的对象（比如arguments对象、DOM NodeList 对象）、Generator 对象，以及字符串 for...in循环有几个缺点。 数组的键名是数字，但是for...in循环是以字符串作为键名“0”、“1”、“2”等等。 for...in循环不仅遍
Python数据序列
less is more
12-13 2173
python课件笔记
Python—数据容器
陈艺秋的博客
04-07 372
Python replace() 方法把字符串中的 old（旧子字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。跟字符串一样列表也支持下标索引，我们知道在列表中可以存储多个以逗号分隔的元素，每个元素都有对应的下标索引，从前向后的方向，从0开始依次递增。字符串是一个无法修改的序列，如果你想用一个新值通过访问下标的方式替换掉以前的值是不会成功的同样删除，追加字符都不行，""-- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
沉浸式过Python基础（2经典练习- 判断和循环的使用）
weixin_45627194的博客
05-30 1095
# 求阶乘 例如：5!=5*4*3*2*1 ``` i=1 j=5 mul=1 for i in range(1,j+1): mul=mul*i print("{0}!={1}".format(j,mul)) ``` # 经典图形 ``` i=1 j=1 for i in range (1,6): for j in range (1,i+1): print("*",end=" ") print("\n") ```
python基础五：元组的index，del，count方法及字典的修改、增加、删除（del、clear）、遍历（keys、values、items）
Chenftli的博客
04-16 6393
元组：index、del、count的方法。index的用法：用来查找元组中元素对应的下标。格式：元组变量名.index(查找的元素)实例： del的用法：用来删除整个元组。格式：del 元组变量名实例： count的用法：用来统计元组中指定元素的个数。格式：元素变量名.count(查找的元素)实例： 字典：查找、修改、增加、删除、遍历。查找用法：直接...
遍历:把一个数据容器中的元素全部取出来使用
qq_59517599的博客
07-21 773
1.for循环是最便历数据容器最好的方法:1.兼容性好2.逻辑简单(好交接) for(leti=0;i<arr.length;i++){ console.log(arr[i]) } 2、ofEach是for循环后来出的方法但是它不返回新数组直接操作原数组(一般不推荐使用) vararr=[100,200,300] arr.forEa...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值