Python元组,列表及字典

Python基础之列表、元组、字典、集合 文章目录前言一、列表List1.定义列表2.基本操作二、使用步骤1.引入库2.读入数据总结 前言         Hello,各位小伙伴大家好,我是紫水晶的微光。本篇文章介绍Python的列表、元组、字典、集合。快来跟我一起学习吧!         列表、元组、字典、集合都是Python内置的数据类型。 一、列表List 1.定义列表 1.格式. 阅读详情

1.列表

# 数组:数据类型必须相同; arr = [1,2,3]
# 列表: 可以是不同数据类型的集合

列表的定义

l1 = [1,2,3,4,5]
print(l1,type(l1))

l2 = [1, 4.5, 1+2j, "hello"]

print(l2, type(l2))


列表的特性

# 字符串的特性: 索引, 切片, 连接, 重复, 成员操作符;
students_name = ['harry', 'westos', 'fentiao', 'natasha']

# 1. 索引
# 正向索引
print(students_name[0])
# 反向索引
print(students_name[-1])

# 2. 切片
print(students_name[::-1])

s = "hello xiao mi"   # "mi xiao hello"
print(" ".join(s.split()[::-1]))

# 3. 重复
print(students_name*3)

# 4. 连接
print(students_name + ['Bob', 'Lilei'])

# 5. 成员操作符
print('Bob' in students_name)
print('fentiao' in students_name)

# 6. for循环遍历列表元素
for student in students_name:

    print("学生姓名:%s" %(student))

# 7. 列表里面嵌套列表
goods = [
    ['apple', 2, 100],
    ['banana', 3, 50],
    ['computer', 4000, 13]
]
# 嵌套索引

print(goods[0][0])


列表特性练习_逗号代码

假定有下面这样的列表:
    names = ['fentiao', 'fendai', 'fensi', 'apple']
    输出结果为:'I have fentiao, fendai, fensi and apple.'
考察点:
    切片:
    字符串的join方法:
# ','.join(names)
names = ['fentiao', 'fendai', 'fensi', 'apple']
print("I have " + ",".join(names[:-1]) + ' and ' + names[-1])
# 求列表的长度

# print(len(names))


列表的增加

names = ['fentiao', 'fendai', 'fensi', 'apple']
# append: 追加, 追加元素到列表的最后;
names.append('westos')
print(names)
names.append(['linux', 'R', 'matlab'])
print(names)
# # insert: 添加元素到指定索引的前面;
names.insert(0, 'java')
print(names)
# # extend: 追加多个元素到列表中;
names.extend(['c', 'C++', 'Go'])

print(names)


列表的删除

names = ['fentiao', 'fendai', 'fensi', 'apple', 'fendai']
# remove: 删除指定的值
names.remove('fendai')
print(names)
# names.pop(): pop删除指定索引的值, 默认情况删除最后一个元素;
# a = name.pop(), a就是删除的那个元素;
value = names.pop(0)
print(value)
print(names)
# del删除列表元素
# del names[0]
# del names[-1]
# del names[1:]
# del names[:-1]
# del names
# # clear: 清空列表
# names.clear()

# print(names)


列表的修改

names = ['fentiao', 'fendai', 'fensi', 'apple', 'fendai']
# 通过索引, 重新赋值;
names[0] = 'redhat'
print(names)
# 通过切片重新赋值
names[:2] = ['java', 'C']

print(names)


列表的查看

names = ['fentiao', 'fendai', 'fensi', 'apple', 'fendai', 'A', 'a', 'ab', 'Ab']
# 查看指定元素的索引值;
print(names.index('fentiao'))
print(names.count('fendai'))
# 按照指定的ASCII码进行排序的;
# names.sort()
# print(names)
# 不区大小写进行排序;
names.sort(key=str.lower)
print(names)
# 列表的反转; 类似于li[::-1]
li = [10, 3, 89, 80]
li.reverse()

print(li)


列表方法练习_用户管理系统

用户登陆系统Version2:
   1). 已知多个用户名和密码分别保存在列表中;
   2). 判断用户名是否存在,
           如果登陆的用户不存在,则报错;;
           如果用户存在, 则判断密码是否正确:
                    如果正确, 输出用户登陆成功;
                    如果不正确, 输出登陆失败;
        3). 为防止黑客暴力破解密码, 登陆最多有3次机会;
"""
names = ['root', 'student']
passwds = ['redhat', 'student']
tryCount = 0
while tryCount < 3:
    tryCount += 1
    inuser = input("用户名:")
    # 1.判断用户是否存在?
    if inuser in names:
        # 2. 判断密码是否正确?
        inpasswd = input("密码:")
        # 找出系统存储的inuser用户的密码;
        index = names.index(inuser)   # inuser='root', index=0
        passwd = passwds[index]     # passwd='redhat'
        if inpasswd == passwd:
            print("%s登陆成功!" %(inuser))
            break
    else:
        print("用户名%s不存在" %(inuser))
else:

    print("尝试次数超过3次!")


列表嵌套操作

import pprint
li1 = [
    [1, 2, 3],
    [2, 3, 4],
    [3, 4, 5]
]
li2 = [
    [2, 3, 4],
    [1, 2, 3],
    [1, 2, 3]
]
# numpy,  pandas, matplotlib
result = [
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0]
]
#  i : 0, 1, 2
for i in range(len(li1)):
    # j: 0, 1, 2
    for j in range(len(li1[i])):
        # [0][0], [0][1], [0][2]
        # [1][0]
        result[i][j] = li1[i][j] + li2[i][j]

pprint.pprint(result)


通过列表实现栈的数据结构

a = 1
stack = [1,2,3,4]
# 栈的工作原理: 先进后出
# 入栈;
# 出栈:
# 栈顶元素:
# 栈长度
# 栈是否为空
# 2. 队列的工作原理: x先进先出
# 入队, 出队, 队头, 队尾, 队列长度, 队列是否为空, 显示队列元素
stack = []
info = """
            栈操作
            
        # 1). 入栈; 
        # 2). 出栈:
        # 3). 栈顶元素
        # 4). 栈长度
        # 5). 栈是否为空     
"""
while True:
    print(info)
    choice = input("请输入选择:")
    if choice == '1':
        item = input("入栈元素:")
        stack.append(item)
        print("元素%s入栈成功" %(item))
    elif choice == '2':
        # 出栈先判断栈是否为空;
        if  not stack:
            print("栈为空, 不能出栈")
        else:
            # item是弹出的那个元素;
            item = stack.pop()
            print("元素%s出栈成功" %(item))
    elif choice == '3':
        if len(stack) == 0:
            print("栈为空, 无栈顶元素")
        else:
            print("栈顶元素为%s" %(stack[-1]))
    elif choice == '4':
        print("栈长度为%s" %(len(stack)))
    elif choice == '5':
        if len(stack) == 0:
            print("栈为空")
        else:
            print("栈不为空.")
    elif choice == 'q':
        print("欢迎下次使用!")
        break
    else:

        print("请输入正确的选择!")


栈的应用练习_棒球比赛成绩

你现在是棒球比赛记录员。
给定一个字符串列表,每个字符串可以是以下四种类型之一:
1.整数(一轮的得分):直接表示您在本轮中获得的积分数。
2. "+"(一轮的得分):表示本轮获得的得分是前两轮有效 回合得分的总和。
3. "D"(一轮的得分):表示本轮获得的得分是前一轮有效 回合得分的两倍。
4. "C"(一个操作,这不是一个回合的分数):表示您获得的最后一个有效 回合的分数是无效的,应该被移除。
每一轮的操作都是永久性的,可能会对前一轮和后一轮产生影响。
你需要返回你在所有回合中得分的总和。
示例 1:
输入: ["5","2","C","D","+"]
输出: 30
解释:
第1轮:你可以得到5分。总和是:5。
第2轮:你可以得到2分。总和是:7。
操作1:第2轮的数据无效。总和是:5。
第3轮:你可以得到10分(第2轮的数据已被删除)。总数是:15。
第4轮:你可以得到5 + 10 = 15分。总数是:30。
示例 2:
输入: ["5","-2","4","C","D","9","+","+"]
输出: 27
解释:
第1轮:你可以得到5分。总和是:5。
第2轮:你可以得到-2分。总数是:3。
第3轮:你可以得到4分。总和是:7。
操作1:第3轮的数据无效。总数是:3。
第4轮:你可以得到-4分(第三轮的数据已被删除)。总和是:-1。
第5轮:你可以得到9分。总数是:8。
第6轮:你可以得到-4 + 9 = 5分。总数是13。
第7轮:你可以得到9 + 5 = 14分。总数是27。
注意:
输入列表的大小将介于1和1000之间。

列表中的每个整数都将介于-30000和30000之间。

判断栈是否为空

stack = []
if stack == []:
    print('NULL')
else:
    print("Not Null")
print(bool([]))
print(bool([1,2,3]))
if stack:
    print(stack)
else:
    print('NULL')
if not stack:

    print('null')


内置方法

print(min([2, 1,2,343,545,6]))
print(max([2, 1,2,343,545,6]))
print(sum([2, 1,2,343,545,6]))
print(sorted([2, 1,2,343,545,6]))
for i in reversed([2, 1,2,343,545,6]):
    print(i,end=',')
print('\n')
for i in zip([1,2,3], ['a','b', 'c']):
    print(i, end=',')
print()
# 枚举, 返回列表的索引及对应的元素值;
for i in enumerate(['a', 'b', 'c']):

    print(i,end=' ')


is和==有何区别

id: 在内存中存储的位置
# type: 变量的;类型
# value: 值是否相等;
# == 判断: type, value
# is: type, value, id
结论:
#   is表示的是对象标识符;表示两个变量的值是否在同一块内存空间;
#   ==表示的是值是否相等;
# 总结: is返回值为True, ==返回一定是True;

a = 'hello'
b = 'hello world'
print(a == b)
c = 18090
d = 18090
print(c==d)

print(id(c), id(d))


深拷贝与浅拷贝

li = [1,2,3,4]
# 拷贝:
# 不是拷贝, 是将li1的指向li的内存位置;
li1 = li
# print(li1 is li)
# 拷贝列表成功
# li2 = li[:]
# print(li2 is li)
# li2.append(5)
# print(li)
# print(li2)
# 浅拷贝
# li = [1, 2, 3, [2, 3]]
# li3 = li[:]
# print(li3 is li)
# print(li3[-1][0] is li[-1][0])
# li3[-1].append(0)
# print(li)

# print(li3)

import copy
li = [1, 2, 3, [2, 3]]
li3 = copy.copy(li)
li.append(1)
# 深拷贝
import copy
li = [1, 2, 3, [2, 3]]
li4 = copy.deepcopy(li)
print(li is li4)
li4[-1].append(0)
print(li)

print(li4)


可变数据类型和不可变数据类型

# 可变数据类型: <有增删改查>列表

# 不可变数据类型: 数值类型都是不可变的;字符串;

2.元组

元组的理解

# 列表: 打了激素的数组;

# 元组: 带了紧箍咒的列表,
names = ['a', 'b', 'c', 1, 1.0, [1, 2]]
tuple_names = (1, 1.0, 2 + 4j, "hello", [1, 2], 10)
print(type(names), type(tuple_names))
# 验证元组的确是不可变的。
# tuple_names[0] = 1
print(tuple_names.index(1))
print(tuple_names.count(1))
# 元组的特性:
# 索引, 切片, 连接, 重复, 成员操作符, for循环
print(tuple_names[0])
print(tuple_names[-1])
print(tuple_names[1:])
print(tuple_names[:-1])
print(tuple_names[::-1])
print(tuple_names + (1,2,43))
# 不同数据类型可以连接么?(除了数值类型之外, 不同数据类型之间不可以连接)
# print([1,2,3]+ (1,2,4))
# print('hello'+[1,2,3])
print(1+2+4j)
print(tuple_names*3)
print(1 in tuple_names)

print(1 not in tuple_names)


元组应用_两变量交换数据

# 元组应用的第一个场景:
x = 1
y = 2
x, y = y, x
# 1. 先把t = (y,x)封装为一个元组, 开辟了一个新的内存空间;
# 2. x = t[0] = 2
# 3. y = t[1] = 1
print(x,y)
# 2. 元组应用的第2个场景:
print("hello %s, hello %s" %("python", "c"))
t = ('python', 'c')

print("hello %s, hello %s" %t)


解压赋值给多个变量

# 元组的赋值
t = ('fentiao', 5, 18)
name, age, weight = t
print(name, weight,age )
li = ['fentiao', 5, 18]
name, age, weight = li

print(name, weight,age )


3.集合

集合数据类型

# 集合元素是不可重复的;
s = {1, 2, 3, 1, 2, 3}
print(s)
# 列表去重;
names = ['hello', 'world', 'hello']
print(list(set(names)))
# 集合的特性: (索引, 切片, 重复, 连接,)===> 不支持, 因为无序;  成员操作符, for循环 ===> 支持;
# 集合是无序的数据类型: 添加元素的顺序和存储的顺序无关;
s = {2,5,8,20}
s
{8, 2, 20, 5}
s.add(6)
s
{2, 5, 6, 8, 20}
# print(s[0])
# print(s[1:])
# print(s*3)
# print(s + {6,7,8})
print(1 in s)
for i  in s:

    print(i, end='')


集合的增删改查

s = {'b', '3', 'a'}
# # 增加单个元素;
# s.add(4)
# print(s)
# # 增加多个元素;
# s.update({4, 5, 6})
# print(s)
# # 删除指定元素
# s.remove(1)
# print(s)
# # 随机删除集合元素
# s.pop()
# print(s)
s.clear()

print(s)

集合操作

# s = {1, 2, 3, 1, 2, 3}
# print(s)
# # 去重
# li = [1, 2, 3, 1, 2, 3]
# print(list(set(li)))
# s1 = {1, 2, 3}
# s2 = {1, 2, 4}
# print("并集:", s1.union(s2))
# print("交集:", s1.intersection(s2))
# # 求交集时, 把s1的值更新为交集的值;
# s1.intersection_update(s2)
# print(s1)
# print(s1.difference(s2))    # s1-instersection(s1,s2)
# print(s2.difference(s1))    # s2-intersection(s1,s2)
# # 求差集时, 把s2的值更新为差集的值;
# print(s2.difference_update(s1))    # s2-union(s1,s2)
# print(s2)
# s1 = {1, 2, 3}
# s2 = {1, 2, 4}
# # 对等差分;
# print(s1.symmetric_difference(s2))
# print(s1 | s2)
# print(s1 & s2)
# print(s1 - s2)
# print(s2 - s1)
# math = ['name1', 'name2']
# english = ['name1']
s1 = {1, 2, 3}
s2 = {1, 2, 4}
# s1是s2的子集?
print(s1.issubset(s2))
# s1是s2的父集?
print(s1.issuperset(s2))
# s1和s2没有交集么? 如果没有交集True,否则返回False;

print(s1.isdisjoint(s2))


集合练习_华为机试题

(华为机试题)题目描述
明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,
他先用计算机生成了N个1到1000之间的随机整数(N≤1000), N是用户输入的,对于
其中重复的数字,只保留一个,把其余相同的数去掉,不同的数对应
着不同的学生的学号。然后再把这些数从小到大排序,按照排好的顺
序去找同学做调查。请你协助明明完成“去重”与“排序”的工作;
count: 100
1, 4, 34,
# 在1-1000之间随机生成10个数字
random.sample(range(1,1000), 10)
sorted()

li.sort()

import random
# print(random.sample(range(1,1000), 10))
# print(random.randint(1,1000))
# 将input接收的str,清值转化为int类型;
N = int(input("N:"))
# list, set, tuple(x)
# 定义空集合时, 不能为s={}, 应该是s = set()
s = set()
for i in range(N):   # 4, (0,1,2,3)
    num = random.randint(1,1000)
    # 将随机生成的数加入到集合中;
    s.add(num)
# 对集合进行排序;

print(sorted(s))


集合练习

1. 共同好友;
        你的好友A,B,C 他的好友C,B,D, 求共同好友:
2.   微信群提醒:
        XXX与群里其他人都不是微信朋友关系
s1, s2, s3
s1 = {s4, s5, s6}
s2 = {s1, s3, s6}
      s3 in (s1 | s2)
3. 权限判断:
        有一个API,要求同时具备A,B,C权限才能访问,目前用户权限为B,C,D,判断该用
户能否访问该API;
实质看用户权限是否为ABC的父集;
ABC     ABCD
ABC     ADF
4. 集合练习:
               随机产生2组各个数字的列表,每组10个数字,如下要求:
                    每个数字取值范围[10,20]
                    统计20个数字中,一共有多少个不同的数字?  # {1,2,3} {2,3,4} # 并集
                    2组中,不重复的数字有几个?分别是什么?{1,2,3} {1,2,4}  # 对等差分;
                    2组中,重复的数字有几个?分别是什么?
5. 一个总任务列表,储存所有任务,一个完成的任务列表。找出未完成的任务; # 实质上是求差集的。
all_task = ['task1', 'task2', 'task3']
complete = ['task1']

import random
li1 = []
li2  = []
for i in range(10):
    li1.append(random.randint(10,20))
    li2.append(random.randint(10,20))
print(li1, li2)

s1 = set(li1)
s2 = set(li2)
print("20个数字中共有%s个不同的数字" %(len(s1 | s2)))
sy_set = s1.symmetric_difference(s2)
print(" 2组中,不重复的数字有%s个, 分别是%s" %(len(sy_set), sy_set))

inster_set = s1 & s2

print("2组中,重复的数字有%s个,分别是%s" %(len(inster_set), inster_set))

4.字典

字典_创建

# 定义空集合, 必须set(),
# {}默认的类型为字典;
d = {}
print(type(d))
# 字典: key-value值, 键值对;
# value值可以是任意数据类型: int,float,long, complex, list, tuple,set, dict
d = {
    '王旭': [18, '男', "请假"],
    '张龙': [18, '男', '俯卧撑']
}
print(d['张龙'])
d2 = {
    'a': 1,
    'b': 2
}
print(d2)
d3 = {
    'a': {1, 2, 3},
    'b': {2, 3, 4}
}
print(d3)
# 字典的嵌套;
students = {
    '13021001': {
        'name':'张龙',
        'age':18,
        'score':100
    },
    '13021003': {
        'name': '张',
        'age': 18,
        'score': 90
    }
}
print(students['13021003']['name'])
# 工厂函数;
l = list([1,2,3])
print(l)
d5 = dict(a=1, b=2)
print(d5)
#
cardinfo = {
    '001':'000000',
    '002':'000000'
}
# fromkeys第一个参数可以列表/tuple/str/set, 将列表的每一个元素作为字典的key值,
#  并且所有key的value值一致, 都为'000000';
print({}.fromkeys({'1', '2'}, '000000'))
# 字典必须是不可变数据类型;d = {[1,2,3]:1}(x)
# 可变数据类型:list, set,  dict

# 不可变: 数值类型, str, tuple


字典的特性

# 索引, 切片, 重复, 连接,成员操作符, for
# set不支持 索引, 切片, 重复, 连接,, 因为set是无序的;
# 1. 判断字典是否是无序的?
# python2中字典加入顺序和存储顺序不一致;
# python3中字典加入顺序和存储顺序一致;
d = {
    '1': 'a',
    '8': 'b'
}
# print(d['1'])
# 字典是不支持索引的;
# print(d[0])
# 字典是不支持切片的;
# print(d[::])
# 字典的重复和连接无意义, 字典的key值是唯一的;
# print(d*3)
# 成员操作符;判断的是某个值是否为字典的key;
# print('1' in d)
# print('1' not in d)
# 字典for循环时, 默认遍历字典的key值;
for key in d:
    print(key)
# 遍历字典:
for key in d:

    print(key, d[key])


字典的增加

services = {
    "http":80,
    'ftp': 21,
    'ssh':22
}
# # 1. 增加一个元素;
#   1). 如果key值存在, 则更新对应的value值;
#   2). 如果key值不存在, 则添加对应的key-value值
# services['mysql'] = 3306
# print(services)
# services['http'] = 443
# print(services)
# 2. 添加多个key-value值;
#   1). 如果key值存在, 则更新对应的value值;
#   2). 如果key值不存在, 则添加对应的key-value值
# service_backup = {
#     'https':443,
#     'tomcat':8080,
#     'http':8080
# }
# services.update(service_backup)
# print(services)
# services.update(flask=9000, http=8080)
# print(services)
print(services)
# 3.setdefault添加key值;
#   1). 如果key值存在, 则不做修改;
#   2). 如果key值不存在, 则添加对应的key-value值
services.setdefault('http',9090)
print(services)
services.setdefault('oracle',44575)

print(services)


字典的删除

services = {
    "http":80,
    'ftp': 21,
    'ssh':22,
    'mysql':3306
}
# 1.
# del services['http']
# print(services)
# 2. pop删除指定key的key-value对,
#   1). 如果key存在, 删除, 并且返回删除key对应的value值;
#   2). 如果key不存在, 直接报错
# item = services.pop('http')
# print(item)
# print(services)
# item = services.pop('https')
# print(item)
# print(services)
#3. popitem删除最后一个key-value值;
item = services.popitem()
print("删除的key-value对是:", item)
print(services)
# 4. 清空字典内容;
services.clear()

print(services)


字典的查看

services = {
    "http":80,
    'ftp': 21,
    'ssh':22,
    'mysql':3306
}
# 查看字典的key值;
print(services.keys())
# 查看字典的value值;
print(services.values())
# 查看字典的(key,value)值;
print(services.items())
# 1. 查看key的value值;key不存在,则报错;
print(services['http'])
# print(services['https'])
# 2. 查看key的value值;
#       key不存在, 默认返回None;
#       key不存在, 有default值, 则返回default值;
print(services.get('http'))
print(services.get('https'))

print(services.get('https', 443))


python 列表、元组、字典、集合的区别 介绍 python中字典 (Dictionary)、元组 (Tuple)、字典 (Dict)、集合 (Set)的区别 阅读详情

相关推荐

Python字符串,列表,元组,字典

一、字符串 字符串:在Python中在单引号或双引号中的内容就是字符串 字符串每个字符都有索引值,从左到右依次是 0,1, 2 ,3.....,从右到左分别是-1,-2,-3...... 字符串的截取: str = '初学者小攀' #定义一个字符串 print(len(str)) # 获取字符串长度 print(str[起始值:终止值:步长]) # 截取字符串 可以用 in 或者 not in 检测字符串是否在某个字符串中,存在返回True,不存在返回False。 字符串的查找与统计

m0_56887993的博客 1817

复杂链表的赋值

#include #include using namespace std; struct ComplexNode{  int  _data ; // 数据  struct ComplexNode * _next; // 指向下一个节点的指针  struct ComplexNode * _random; // 指向随机节点(可以是链表中的任意节点 or

KOwzb的博客 756

数组定义及操作在线实验闯关

本关任务:对比Python的基本数据类型(列表、元组、字典等),数组具有更灵活的数据存储方式,比如一维数组和二维数组或者矩阵,特别是对于数值型数据来说更有优势,根据给出的列表L1=[1,2,3,4,0.1,7]和嵌套列表L2= [[1,2,3,4],(5,6,7,8)],请利用numpy包中的array()函数将其定义为一维数组和二维数据。#将列表L1定义为一维数组#将嵌套列表L2定义为二维数组#在函数中定义以上数组 , 并返回计算结果l1 , l2。

Junds0的博客 7897

Python基础—元组详解

1、元组的创建 元组(tuple):元组本身是不可变数据类型,没有增删改查 元组内可以存储任意数据类型 t = (1,2,3,4,True,'red') print(type(t)) print(t) ###元组里面包含可变数据类型,可以间接修改元组的内容 t = ([1,2,3],4) print(t) t[0].append(4) print(t) ###元组中如果只有一个元素的时候,...

weixin_43314056的博客 856

从充电管理芯片里‘偷师’:拆解一个PMOS双向开关电路,搞定你的固态继电器需求

本文深入解析了PMOS双向开关电路在固态继电器应用中的设计要点,重点探讨了防电流倒灌和高侧双向开关的实现技巧。通过拆解充电管理芯片中的PMOS背靠背结构,工程师可以构建高效可靠的固态开关方案,适用于智能硬件和电池管理系统。文章还提供了关键参数选择、电路优化建议及实测数据对比,助力解决电源防反接等工程难题。

weixin_33698043的博客 487

UWB学习——day4

总的来说,BPM-BPSK调制方案是一种利用脉冲位置和相位来编码信息的高效数字调制技术,特别适用于UWB通信系统,以实现高速数据传输和频谱效率。这种方式将时间和相位综合使用,从而提高了数据传输的容量。总之,超外差结构是一种接收器设计,通过将不同频率的信号转换到一个共同的中间频率来提高信号选择性和抗干扰性。超外差结构是一种用于接收器的电子电路设计,它的目标是从无线信号中提取有用的信息,比如音频、数据或图像。该芯片的接收机是超外差结构,所谓超外差结构一种基于频率转换的接收器架构,旨在提高信号选择性和抗干扰性。

许帅的博客 2558

第五天 python中列表

关于python的列表基础使用,环境使用的是python3.8.6 shell IDLE 欢迎大家指出我的问题,你我共同进步 列表的创建和访问列表 列表的创建时通过中括号来实现的[] >>> [1,2,3,4] [1, 2, 3, 4] 通过for循环来遍历列表的值 s = [1,2,3,4,'thisis'] for i in s: print(i) 也可以通过索引 的方式进行访问列表的内容 s = [1,2,3,4,'thisis'] s[1] #访问到的值的就是列表中的2,

weixin_45612728的博客 856

Python入门之机器学习(非常详细)篇幅拉满,一般人看不完!

什么是机器学习?监督学习 supervised learning;非监督学习 unsupervised learning;半监督学习 semi-supervised learning;强化学习 reinforcement learning;监督学习是不断向计算机提供数据(特征),并告诉计算机对应的值(标签),最后通过大量的数据,让计算机自己学会判断和识别。例如Google Photo,你在APP中输入狗,这时就会弹出与狗相关的图片,这背后使用的算法就是监督学习。

xiaolinyui的博客 2万+

python——列表

列表 列表的创建 list = [1,1.2,True,'westos'] print(list,type(list)) # 列表里也可以嵌套列表 list2 = [1,2,3,4,[1,1.2,True,'westos']] print(list2,type(list2)) service = ['http','ftp','ssh'] 列表的特性 # 索引 # 正向索引 p...

qq_43309149的博客 964

(二)目标检测之 HOG+SVM 算法

文章目录一、概述二、方法概述三、积分图四、AdaBoost五、级联检测六、结果七、复现八、总结参考资料 一、概述   梯度直方图HOG(Histogram of Oriented Gradients)是法国人Dalal在2005年CVPR会议上提出的特征提取算法,并将其与 SVM 配合,用于行人检测。论文地址:Histograms of oriented gradients for human detection HOG有个优点,提取的边缘和梯度特征能很好的抓住局部形状的特点,且因是对图像做了Gamma

天青如水的博客 1万+

数电-基于FPGA的自动售货控制系统设计

本次数电的课程设计是设计一款基于FPGA的自动售货控制系统,因为手上暂时没有FPGA的板子,所以先采用proteus仿真进行设计,观察系统效果,等之后FPGA板子下发,再移到quartus上调试和下载。同样是自己第一次自主设计电路系统,可能在功能上不完整或者逻辑上有错误,大家多多包涵,欢迎沟通交流。

gg1067的博客 2293

Python 列表,字典,元组,集合总结

列表是Python中最常用的数据结构之一,它是一个有序可变的序列,可以存储任意类型的元素。列表用方括号[]表示,元素之间用逗号分隔。元组是一个有序不可变的序列,用圆括号()表示。元组一旦创建,其内容不可修改。集合是一个无序不重复的元素集合,用花括号{}表示。集合中的元素必须是不可变类型(如整数、字符串、元组等)。字典是一个无序的键值对集合,用花括号{}表示。字典中的每个元素由一个键(Key)和一个值(Value)组成,键必须是不可变类型。列表适合存储有序且可能变化的数据。元组。

cxk 2469

colmap+openMVS稠密重建

简要记录一下colmap+openMVS稠密重建相关使用。

weixin_41631106的博客 2245

python中的列表、元组、字典的介绍与使用

在 Python 中,列表(list)、元组(tuple)和字典(dictionary)是三种常见的数据结构。 列表是一有序的可变容器,可以包含多个元素。元组是一个有序的不可变容器。字典是一个无序的可变容器,用于存储键值对。 1.使用场景以及区别图 何时使用 列表:当你需要一个可修改、顺序的容器时。 元组:当你需要一个不可以修改的顺序容器时,通常用于函数返回多个值等。 字典:当你需要根据键快速查找值时,适用于存储关联数据。

快乐学习 3648

基于综合阻抗特征的配电架空线路单相断线故障区段定位研究

本文提出了一种基于综合阻抗特征的配电架空线路单相断线故障区段定位方法。通过分析故障后正序、负序阻抗变化,构造综合阻抗判据实现精准定位。仿真结果表明:该方法能有效识别故障区段,差异度判据显著(故障区段达0.508,非故障区段<0.016);对过渡电阻(1-200Ω)和负荷变化具有强鲁棒性,定位准确率不受影响。相比传统方法,综合阻抗法放大了断线故障特征,解决了弱故障信号检测难题,为配电网安全运行提供了可靠的技术手段。

AI的内部世界的博客 83

SpringBoot实现快速导入EXCEL

MaterialMonitorController.java @Log(title = "物料监测", businessType = BusinessType.IMPORT) @RequiresPermissions("system:materialMonitor:import") @PostMapping("/importData") @ResponseBody ...

LEN程序员的一生 4817

python中的列表、元组、字典、集合

列表、元组、字典、集合

qq_45897677的博客 6336

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Python 中列表、元组、字典、集合方法汇总

本文系统介绍了Python四种核心数据结构:列表(List)、元组(Tuple)、字典(Dictionary)和集合(Set)。列表作为可变有序集合,详细讲解了添加/删除元素、查找排序等操作;元组作为不可变序列,重点说明访问方式和内置函数;字典作为键值对映射结构,解析了增删改查及视图对象;集合作为无序不重复元素集,阐述了集合运算和关系判断。通过具体代码示例,全面展示了各数据结构的特点和常用方法,为Python编程提供基础支持。掌握这些数据结构能有效提升代码质量和开发效率。

2201_75952812的博客 2643

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

关于python中序列结构,列表、元组、集合、字典的区别

关于python中序列结构,列表、元组、集合、字典的区别列表(list)元组(tuple)元组与列表的区别 列表(list) 列表(list)是python内置的一种数据类型,是可变的序列。在形式上,列表的所有元素都放在一对中括号“[ ]”中,两个相邻的元素间使用逗号“ , ”分割。在内容上,可以将整数、实数、字符串、列表、元组等任何类型的内容放入到列表中,并且同一个列表中,允许元素的类型不相同,因为它们之间没有任何关系。 元组(tuple) 元组(tuple)是python中的另一个数据类型,与列表类似,

777663的博客 9813

python中列表、元组、字典、集合的使用

一、定义与特性 1、列表:列表是一组有序存储的数据,它的特性包括:(1、和一般的变量一样都有唯一的标识命名称;(2、列表中的元素都是相同类型的;(3、列表元素都有索引和值两个属性,索引从0开始,每个索引都对应一个值;(4、有中括号括起来元素,元素之间有逗号隔开。 2、元组:(1、一经定义内容无法改变;(2、元组元素可以是不同的类型;(3、元组使用圆括号括起来元素。 3、字典:(1、字典是在内存中保...

ISmileLi的博客 4534

python(列表、元组、字典)详解

文章目录什么是列表?列表的定义in、max、min在列表中的使用初识元组元组定义列表与元组的区别初识字典字典的结构与创建方法字典支持的数据类型 什么是列表? 列表就是队列 是各种数据类型的集合,也是一种数据结构! 列表是一种有序的,且内容可重复的集合类型 列表的定义 在python中,list代表着列表这种类型,也可以用它定义一个列表 列表的元素存在于一个[]内 列表是一个无限制长度的数据结构 in、max、min在列表中的使用 member=[1,2,3,4,5] print(1 in membe

qq_45927819的博客 3878

Python列表、元组、集合、字典的区别

Python列表、元组、集合、字典的区别和使用场景

做一个乐于分享的程序员 9370

Python 中列表,元组,字典,以及基本队列的解释和区别。

搞清楚Python 中列表,元组,字典,以及基本队列的解释和区别。

m0_74346238的博客 2851

【python】列表元组与字典

列表元组与字典常用总结

gma999的博客 844

Python 中将元组列表转换为字典

在每次迭代中,我们将字典键设置为元组中的第一个元素,并将相应的值设置为第二个元素。类灵活得多,因为它不假定列表中的元组只有 2 个元素——一个键和一个值。,此方法仅在您的元组每个包含 2 个元素(一个键和一个值)时才有效。他们对字典中的每个键值对执行一些操作,或者选择满足条件的键值对的子集。类相反,如果每个元组中的第一个元素是值,这种方法也适用。如果我们尝试解包的值多于或少于元组中的值,则会出现错误。将遍历列表,允许我们将每个键值对设置为特定的元组元素。解包时,确保声明的变量与可迭代对象中的项目一样多。

迹忆客 1万+

Python基础之列表、元组和字典

列表(List)对象 经常被用来存储数据对象。我们可以把列表想象为 一连串的储物格,就像下面这样:其中每个储物格里面都可以存储任何类型的对象注意:是任何类型的对象, 整数、小数、字符串、函数、等等 都可以。也可以存储另一个列表对象。# 方括号用来表示一个列表如果定义列表的时候,里面就存放了一些数据对象,只需要填写到方括号里面就可以了。每个对象之间用逗号隔开。# 这个列表里面就包含了多种类型的对象: 整数、小数 、 字符串。# 列表里面的每个对象,就称之为列表的一个元素。列表中还可以包含另一个。

H931053的博客 3706
上一篇: Python字符串及练习题
下一篇: 学生管理系统及练习题
Thankears
博客等级 码龄9年 25粉丝 32原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值