Python_基本概念_列表

最新推荐文章于 2024-04-29 07:06:22 发布

窗外藏深海

最新推荐文章于 2024-04-29 07:06:22 发布

阅读量812

点赞数 1

分类专栏： python 文章标签：分支结构循环结构基本变量列表

本文链接：https://blog.csdn.net/weixin_41177059/article/details/100883565

版权

python 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Python中不需要先声明变量名及其类型，直接赋值即可

字符串前面加字母r或R表示原始字符串，其中的特殊字符不进行转义，但字符串的最后一个字符不能是\符号

在选择和循环结构中，条件表达式的值只要不是False、0（或0.0、0j等）、空值None、空列表、空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象，Python解释器均认为与True等价。

变量类型：

数字：int，flat，complex

字符串：str 字符串支持使用+运算符进行合并以生成新的字符串

列表：list

字典：dict

元组：tuple

集合：set

布尔型：bool

空类型：None

x=3
print(type(x)) #int
x=3.5
print(type(x)) #float
x=3+5j
print(type(x)) #complex
x='hello world'
print(type(x)) #str
x=[1,2,3]
print(type(x)) #list
x=True
print(type(x)) #bool
x=(2,5,6)
print(type(x)) #tuple
x=None
print(type(x)) #NoneType

条件表达式

算术运算符：+、-、*、/、//、%、**

关系运算符：>、<、==、<=、>=、!=，可以连续使用

测试运算符：in、not in、is、is not

逻辑运算符：and、or、not，注意短路求值

位运算符：~、&、|、 ^、 <<、>>

矩阵乘法运算符：@

短路求值：当进行与运算时（a&&b），当a的值为False时，则直接跳过b值的判断

当进行或运算时（a||b）,当a的值为True时，则直接跳过b值的判断

x=3
y=4
z=x+y  #7
z=x-y    #-1
z=x*y    #12
z=x/y    #0.75
z=x//y #整除运算 0
z=x%y    #3
z=x**y #平方运算 81

z=x and y #4
z=x or y    #3
z=not y    #False

单分支结构

if x :
    print("OK")

双分支结构

if x :
    print("Ok")
else :
    print("No")
# value1 if condition else value2
print("True") if x else print("False")

多分支结构

#多分支
if x==1:
    print("1")
elif x==2 :
    print("2")
else :
    print("3")

Python中缩进代表代码块，取消括号

循环结构

#while
while x:
    break
#for
list=(1,2,3)
for x in list:
    print(x)
else:        #如果没有break则执行else语句
    print("ok")
    #局部变量访问比全局变量快

例题

#编写一个程序，完成以下功能。假设由变量a，判断变量a是否为偶数，若为偶数，则输出a为偶数。无论变量a是否为偶数，都把其值输出出来。编写函数：函数功能是将学生成绩从百分制变换到等级制：
def prin():
        if (a % 2 == 0):
            print(a)
            print("a为偶数")
        else:
            print(a)

#90分及以上 A
#80分-90分之间 B
#70分-80分之间 C
#60分-70分之间 D
#60分以下 E
def score(grade):
    if (grade >= 90):
        return "A"
    elif (grade >= 80 and a < 90):
        return "B"
    elif (grade >= 70 and a < 80):
        return "C"
    elif (grade >= 60 and a < 70):
        return "D"
    else:
        return "E"

#修改猜一猜小游戏：（ 使用random.randint(0, 10) ）要求：可以不停猜，并提示猜大了还是猜小了，直到猜中为止。
def game():
    ans = random.randint(0, 10)
    while True:
        num = input()
        num = int(num)
        if (num > ans):
            print("big")
        elif (num < ans):
            print("small")
        else:
            print("bingo")
            break
#主函数调用
if __name__=="__main__": #相当于C的main函数接口
    a = input()
    a=int(a)
    prin()
    grade=input()
    grade=int(grade)
    print(score(grade))
    game()

Python序列：列表、元组、字典、字符串、集合等

列表是Python中内置有序、可变序列，列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开

在Python中，一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、元组、字典、集合以及其他自定义类型的对象

[10, 20, 30, 40]
['crunchy frog', 'ram bladder', 'lark vomit']
['spam', 2.0, 5, [10, 20]]
[['file1', 200,7], ['file2', 260,9]]

列表创建

使用“=”直接将一个列表赋值给变量即可创建列表对象

a_list = ['a', 'b', 'mpilgrim', 'z', 'example']
a_list = []               //空列表

也可以使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表

a_list = list((3,5,7,9,11))
a_list
//[3, 5, 7, 9, 11]
list(range(1,10,2))
//[1, 3, 5, 7, 9]
list('hello world')
//['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
x = list()          //创建空列表

列表访问

索引访问方式：下标从0开始（可以逆向访问，从尾开始为-1）

切片访问：[起始位置，最终位置，步长]

list_a = list[1:4:2] #起始位置为1，终止位置为4，步长为2

列表运算符

列表之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的列表

表达式	结果	描述
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	连接
['Hi!’] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在
for x in [1, 2, 3]: print x	1 2 3	遍历

列表常用方法

方法	说明
lst.append(obj)	在列表尾部添加新的元素
lst.extend(L)	将列表L中所有元素添加至列表lst尾部
lst.insert(index, obj)	在列表lst指定位置index处添加元素
lst.remove(x)	在列表lst中删除首次出现的指定元素
lst.pop([index])	删除并返回列表lst中下标为index（默认为-1）的元素
lst.clear()	清空列表，但保留对象
lst.index(obj)	从列表中找出某个值第一个匹配项的索引位置
lst.count(obj)	统计某元素在列表的出现次数
lst.reverse()	对列表lst所有元素进行逆序
lst.sort(key=None, reverse=False)	对列表lst中的元素进行排序，key用来指定排序依据，reverse决定升序（False）还是降序（True）
lst.copy()	复制列表

列表元素增加

（1）“+”运算符

aList = [3,4,5]
aList = aList + [7]
#[3, 4, 5, 7]

严格意义上来讲，这并不是真的为列表添加元素，而是创建了一个新列表，并将原列表中的元素和新元素依次复制到新列表的内存空间。操作速度较慢，在涉及大量元素添加时不建议使用该方法。

（2）append()方法

aList.append(9)
aList
#[3, 4, 5, 7, 9]

在当前列表尾部追加元素，原地修改列表，是真正意义上的在列表尾部添加元素，速度较快

所谓“原地”，是指不改变列表在内存中的首地址。

id(aList)前后地址是不变的。

（3）extend()方法

a = [1,2,3]
id(a)
#25289752
a.extend([7,8,9])
a
#[1, 2, 3, 7, 8, 9]
>>> id(a)
#25289752
a.extend((15,17))
a
[1, 2, 3, 7, 8, 9, 15, 17]

可以将另一个迭代对象的所有元素添加至该列表对象尾部。通过extend()方法来增加列表元素也不改变其内存首地址，属于原地操作

（4）insert()方法

aList=[3, 4, 5, 7, 9, 11, 13, 15, 17]
aList.insert(3, 6)                #在下标为3的位置插入元素6
aList
#[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

将元素添加至列表的指定位置

注意：会引发数据的移动！

列表元素的删除

（1）del命令

删除列表中的指定位置上的元素

a_list = [3,5,7,9,11]
del a_list[1]
a_list
#[3, 7, 9, 11]

（2）pop()方法

a_list = list((3,5,7,9,11))
a_list.pop()
#11
a_list
#[3, 5, 7, 9]
a_list.pop(1)
#5
a_list
#[3, 7, 9]

删除并返回指定位置（默认为最后一个）上的元素，如果给定的索引超出了列表的范围则抛出异常。

（3）remove()方法

a_list = [3,5,7,9,7,11]
a_list.remove(7)
a_list
#[3, 5, 9, 7, 11]

删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常

（4）clear()方法

a_list = [3,5,7,9,7,11]
a_list.clear()

清空列表里所有元素

列表计数

aList
#[3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
aList.count(7)
#1
aList.count(0)
#0
aList.count(8)
#0

使用列表对象的count()方法统计指定元素在列表对象中出现的次数。

列表内置函数

函数	说明
len(list)	列表长度，即元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转成列表

#请用索引取出下面list的指定元素
#L = [['Apple','Google','Microsoft'],['Java','Python','Ruby','PHP'],['Adam','Bart','Lisa']]
if __name__=="__main__":
L = [['Apple','Google','Microsoft'],['Java','Python','Ruby','PHP'],['Adam','Bart','Lisa']]
    for index in range(len(L)):
        print(L[index])

#遍历下面的列表
#lst=['Apple','Google','Microsoft','Java','Python','Ruby','PHP']
LST = ['Apple','Google','Microsoft','Java','Python','Ruby','PHP']
    for index in range(len(LST)):
        print(LST[index])

x = [1,2,1,2,1,1,1]
for i in range(len(x)-1,-1,-1):  # range（起始位置，终止位置，每次操作）
        if x[i]==1:
        del x[i]


x = [1,2,1,2,1,1,1]
for i in x[::]:               #x[::] : 拷贝副本          #切片
     if i == 1:
	     x.remove(i)

列表排序

使用列表对象的sort()方法进行原地排序，支持多种不同的排序方法。

list.sort(key=None, reverse=False) 
>>> aList = [3, 4, 15, 11, 9, 17, 13, 6, 7, 5]
>>> aList.sort()                          #默认升序排序
>>> aList.sort(reverse = True)            #降序排序
>>> aList
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

关键字问题

list.sort(key=None, reverse=False)

key=函数名，该函数的返回值作为元素的权值大小

reverse -- 排序规则，reverse = True 降序， reverse = False 升序

#按转换成字符串的长度排序
>>> aList.sort(key = lambda x:len(str(x)))   #lambda ： 匿名函数 返回值为表达式
>>> aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]

列表排序

使用内置函数sorted()对列表进行排序并返回新列表

>>> aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
>>> sorted(aList)                            #升序排序
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> sorted(aList,reverse = True)             #降序排序
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

列表逆序

使用列表对象的reverse()方法将元素原地逆序

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList.reverse()
>>> aList
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

序列操作的常用内置函数1

len(列表)：返回列表中的元素个数，同样适用于元组、字典、集合、字符串等

max(列表)、 min(列表)：返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等

sum(列表)：对列表的元素进行求和运算，对非数值型列表运算需要指定start参数，同样适用于元组、range

>>> sum(range(1, 11))      #sum()函数的start参数默认为0
55
>>> sum(range(1, 11), 5)   #指定start参数为5，等价于5+sum(range(1,11))
60
>>> sum([[1, 2], [3], [4]], [])    #这个操作占用空间较大，慎用
[1, 2, 3, 4]

序列操作常用内置函数2：zip()

zip()函数返回可迭代的zip对象

>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(aList, bList)                 #返回zip对象
>>> cList
#<zip object at 0x0000000003728908>
>>> list(cList)                       #把zip对象转换成列表
#[(1, 4), (2, 5), (3, 6)]

序列操作常用内置函数3: enumerate()

enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效

>>> for item in enumerate('abcdef'):
    print(item)
'''
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')
'''

列表推导式

列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性

列表推导式语法形式为

[expression for expr1 in sequence1 if condition1
            for expr2 in sequence2 if condition2
            for expr3 in sequence3 if condition3
            ...
            for exprN in sequenceN if conditionN]

列表推导式在内部实际上是一个循环结构，只是形式更加简洁，例如：

>>> aList = [x*x for x in range(10)]

#等价于

>>> aList = []

>>> for x in range(10):

      aList.append(x*x)

使用列表推导式实现嵌套列表的平铺

>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
#等价于
>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> result = []
>>> for elem in vec:
    for num in elem:
  result.append(num)
>>> result
[1, 2, 3, 4, 5, 6, 7, 8, 9]

例题

#使用random模块，随机生成一个每个数据元素都小于100且列表长度为20的列表。并调整列表元素顺序，把所有奇数都放到前面，偶数都放到后面。（注意：布尔类型可以比较大小）

>>>result = [random.randint(0,100) for i in range(20)]
>>>result.sort(key=lambda x:x%2==0,reverse = False)
>>>    print(result)






#aList = [-1,-4,6,7.5,-2.3,9,-11]，采用列表推导式过滤掉负数并且将正数的值求平方组成一个列表。


>>>alist = [-1,-4,6,7.5,-2.3,9,-11]
>>>l=[i**2 for i in alist if i > 0]
>>>  print(l)

窗外藏深海

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python_基本概念_列表

Python_元组 Python_集合可迭代对象、迭代器、生成器字符串Python中不需要先声明变量名及其类型，直接赋值即可字符串前面加字母r或R表示原始字符串，其中的特殊字符不进行转义，但字符串的最后一个字符不能是\符号在选择和循环结构中，条件表达式的值只要不是False、0（或0.0、0j等）、空值None、空列表、空元组、空集合、空字典、空字符串、空ra...
复制链接

扫一扫