Python list初始化一个可变长度 python list变量

转载

智能开发艺术家 2023-10-08 09:06:41

数据类型

基本的数据类型有：数值int、字符串str、列表list、元组tuple、字典dict、集合set
数值：int 、long 、bool、float、complex
Python3中已经将int 、long取缔，只有int一种了
bool中的True、False是关键字，注意这两个字母的书写

在Python中，strings,tuples和numbers是不可更改的对象，而list，dict等则是可以修改的对象。
** 不可更改对象：**就是创建了一个新的对象，重新指向。

list: 类似于C语言中数组
常用方法：L.append(x)， L.count(x)， L(len), L.enxtend(alist) ,L.index(x) ,L.insert(i,x )
L.pop(i) , L.remove(x) , L.reverse() ,L1=sorted(L) 或者L.sort()
max(L), min(L) ,max(L) 等

a. 访问列表

>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>print(motorcycles )
 ['honda', 'yamaha', 'suzuki']  #原样输出
>>>print(a[0])
honda    #第一个元素值

b. 修改，添加和删除元素

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles[0] = 'ducati'
print(motorcycles)    #此时第一个元素值已经改变了，可以修改任意位置元素值

添加：追加元素

motorcycles.append('ducati')  #在末尾追加了新的元素
print(motocycles)  

motorcycles = []  #创建一个空的列表，然后追加元素很常见
motorcycles.append('honda') 
motorcycles.append('yamaha') 
motorcycles.append('suzuki') 
print(motorcycles)

添加：插入元素

>>>motorcycles.insert(0, 'ducati')  #insert()可以在任何位置进行插入数据，需要指定插入数据的索引和值
>>>print(motorcycles)
['ducati', 'honda', 'yamaha', 'suzuki']

删除：del方法

>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>del motorcycles[0]  #删除第一个元素，del可删除列表中任何位置元素
>>>print(motorcycles)
['yamaha', 'suzuki']

删除：pop()方法

list1.pop(0) #从指定位置删除元素

删除：remove()方法

if 3 in list1:
	list1.remove(3)  #一般先判断元素在不在列表中，然后再进行删除该元素

清空元素：clear()

list1.clear()

合并两个列表

list1=[1,3,4]
list1.extend([100,200])
print(list1)  # [1,3,4，100，200]

c. 列表中的最大值，最小值，求和, 排序

>>>li=list(range(1,101)
>>>print(sum(li))
5050
>>>print(max(li))
100
>>>print(min(li))
1


list2=sorted(list1)# sorted函数 返回列表排序后的拷贝不会修改传入列表
list3=sorted(list1,reeverse=True)
list4=sorted(list1,key=len)  #通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表排序

list1.sort(reverse=True)  #直接在列表对象上进行排序

字符串：
a. 使用方法修改字符串的大小，使用方法对字符串进行处理

name="ada lovelace"
#首字母大写
print(name.capitalize())  #Ada lovelace  
#输出时，单词的首字母大写 
print(name.title())    #，结果为： Ada LoveLace
#输出时，都转为大写
print(name.upper())  
 #都转为小写
print(name.lower())  
#计算字符串的长度
print(len(name))  #12,
#从字符串中查找子串的位置
print(name.find('lo')) # 4
print(name.find('sh') # -1
#与find类似但是找不到子串时会引发异常
print(name.index('sh')) 
#检查字符串是否以指定字符串开头
print(name.startswith('ad'))  #True
print(name.startswith('aj')) #False

b. 拼接使用“+” 加号即可

first_name="ada"
last_name="lovelace"
full_name=first_name+" "+last_name
print(full_name)              #输出结果为：ada lovelace

c. 使用制表符和换行来添加空白

>>>print("language:\n\tpython\njava")
language:
	python
java

d. 删除空白
可使用rstrip删除右空白，lstrip删除左空白

>>>language='python  '
>>>language
'python  '
>>>language.rstrip()  #只是暂时删除了空白 ，
'python'      
>>>language
'python  '
>>>language=language.rstrip()  #重新给变量赋值，才能永久的删除看空白
>>>language
'python'

e. 使用字符串避免语法错误,注意单引号和双引号的使用

输出：hello ，my name is "hanyanmei"
>>>print('hello,my name is "hanyanmei" '
输出：hello， 'mary',hahah 
>>>print("hello , 'mary' ,hahah ")

元组：
元组的元素不可修改，元组顾名思义，就是将多个元素组合到一起形成一个元组
为什么有了列表还要使用元组呢？
因为在多线程环境中，使用不可修改对象易于维护，同时对于线程安全等方面省掉很多同步化的开销。

#定义元组
t=('han',24,True)
#获取元组中的元素
print(t[0])
#遍历元组
for i in t :
	print(i)
#给元组赋值
t[0]='meimei'   #错误
#变量t重新引用了新的元组 原来的元组已经被垃圾回收了
t=('meimei',24,True)
#将元组转成列表
person=list(t)
print(person)
#将列表转成元组
t=tuple(persion)

集合
Python中的集合和数学中的集合是一致的，不允许有重复的值，但是可以进行交，并，补集运算

#创建集合
set1={1,2,3,3,4}  
print(set1)  # 1,2,3,4
print(len(set1))  #4
#创建集合的构造器
set2=set(range(1,10))
print(set2)  #1,2，3,4，5,6，7,8，9
#创建集合的推导式语法
set3={num for num in range(1,10) if num%3==0}
print(set3)  # 3,6,9
#向集合添加元素
set1.add(5)
set2.updata([11,12])
#删除元素
set1.discard(2)
print(set1)  # 1,3,4
if 4 in set1:
	set1.remove(4) 
print(set1) # 1,3
print(set1.pop())  #1
#交集
set1.intersection(set2)
print(set1&set2)
#并集
set1.union(set2)
print(set1 | set2)
#差集
set1.difference(set2)
print(set1^set2)

**字典 **
可以存储任意类型对象，键值对使用冒号分开

#创建字典
score={'han':99,'zhangsan':89}
#创建字典的构造器语法
score1=dict(han=99,zhangsan=89)
#通过zip函数将两个序列压成字典
item1=dict(zip(['a','b'],'12')
print(item1)  #结果为{'a':'1','b':'2'}
#通过键可以获得字典中对应的值
print(scores['han'])  #99
#遍历字典中的所有键值对
for key in score:
	print(f'{key}:{score[keky]}')
#更新字典中的值
score['han']=88
score.update(meimei=100)
#删除字典中元素
print(score.popitem())  #删除字典中最后的键值对
print(score.pop('han',88)
#清空字典
score.clear()

变量

Python是动态类型语言，也就是不需要预先声明变量类型。变量类型和值在赋值时进行初始化。
变量的书写方式：字母数字下划线组成不能以数字开头，且大小写敏感

变量的作用域
作用域一共有4种，分别是：
L （local）局部作用域
E （Enclosing）闭包函数外的函数中
G （global）全局作用域
B （build in ）内建作用域
以L–>E–>G–>B 的规则去查找，即：在局部找不到，便会去局部外的局部去找（例如闭包），再找不到就会去全局找，再者去内建中找。

x=int(2.9) #内建作用域

g_count=0 #全局作用域
def outer():
	o_count=1 #闭包函数外的函数中
	def inner():
		i_count=2 #局部作用域

Python中只有模块，类以及函数才会引入新的作用域，其他的代码块如（if/elif/else ,try/except,for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问的。
注意： 如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

global和nonlocal关键字
当内部作用域想要修改外部作用域的变量时，global和nonlocal关键字
如果要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量则需要nonlocal关键字

赋值

赋值：不是将一个值赋值给变量，都是将该对象的引用赋值给变量
注1：赋值语句不会返回一个表达式（可以返回值）

>>>x=1
>>>y=(x=x+1)   #错误
>>>y=x=x+1   #正确，链式赋值

注2：支持n*=10 ,但不支持自增1或者自减1。

可以使用type检查变量的类型

>>> type(1)
<type 'int'>

Python保留字

and, or , not , in 
for , while, break ,continue
if , elif ,else 
try,  except , finally
from ,import , with ,
class , def ,  return ,
print  , 
global ,
assert , exec ,pass,  raise , del ,is ,lambda,yield