python语法（二）适合从java自学python

在努力的坚持着，争取一周一更新吧。这周记录上周看的列表、字典、元组、集合以及字符串的基本方法。

一、列表：

1、列表的生成：

#直接使用[]生成，
list1=['hello',98,'world']
list2=list(['hello',98,'world'])
#使用生成式生成
list3=[i for i in range(1, 11)] #1到10生成
list4=[2*i for i in range(1, 6)] #生成2，4，6，8，10

2、列表的基本操作:

list1=['hello',98,'world']
#查找元素的index（返回第一个出现的元素的索引），不存在会报错，还可以在范围内查找
print(list1.index('hello'))

# 获取index的元素，不存在会报错
print(list1[0])

# 切片,第一个开始索引（默认0），第二个结束索引（默认结束）（开始索引包含在切的范围内，结束的不包含），第三个参数步数（默认1，步长可以为负的，倒着切）
list2=[10,20,30,40,50]
print(list2[0:3:1])

# 判断元素是否在列表中
print(10 in list2)

# 列表循环
for item in list2:
    print(item)

###############################################################

# 在最后面添加一个元素
list2.append(0)

# 在最后面添加多个元素
lst1=[1,2]
list2.extend(lst1)

# 在列表的任意位置添加(第一个参数是指代索引位置)
list2.insert(1,111)

# 在任意列表位置添加多个元素,就是将切出来的替换成新的
lst2=['tihuan','tihuan']
list2[1:3:1]=lst2

################################################################

lst=[1,2,3,4,5,6,7,8]
# 指定删除元素,如果不存在报异常,重复元素只删除第一个
lst.remove(8)

# 指定删除索引的元素，如果不指定代表删除最后一个元素
lst.pop(6)

# 一次最少删除一个
lst[1:3:1]=[]

# 清除列表
lst.clear()

# 删除整个列表
del lst

lst1=[2,2,3,4,5,6]
# 修改一个
lst1[0]=1
print(lst1)
# 修改多个
lst1[0:3]=['wuhu']
print(lst1)

###############################################################

lst=[4,2,8,9,3,1]
# 排序后是原列表,默认的是升序即reverse=False为true的时候是降序
lst.sort()
print(lst,id(lst))

二：字典：（类似java的hashmap）

1、创建以及简单的操作：

score = {'lisi': 40, 'wangwu': 30}
student=dict(name='lisi',age=20)
# 使用内置函数生成,以最短的为主
names=['lisi','zha','sa']
ages=['22','11','33','44']
student1={age:name for name,age in zip(names,ages)}

# 获取值两种方式
print(student['name'])
#print(student['11'])  #如果key不存在会报错
print(student.get('name'))#如果key不存在会返回None
print(student.get('11',99))#如果key不存在则返回后面的99

# 对key是否存在的判断
print('name' in student)
print('nam111e' not in student)

# 删除key和value,如果删除的key不存在会爆粗
del student['name']

# 删除所有key
# student.clear()

2、遍历：

student={'name':'liu','age':22}
# 获取所有的key
keys=student.keys()
print(keys)
print(type(keys))
print(type(list(keys)))

#获取所有的value
values=student.values()
print(values)
print(list(values))

# 获取所有的键值对
items=student.items()
print(items)
print(type(items))
print(list(items))

# 遍历
for key in student:
    print(key,student.get(key))

三、元组：

1、创建：（不可变！）

t1=('python','good','100')
print(type(t1))
# 可以直接省略括号，但是当只有一个元素的时候需要在元素后面加上一个逗号，否则会以为不是元组
t2='python','ddd','aaaa'
t3='py',
t4=('ss',)
print(type(t3))
print(type(t4))
print(type(t2))

# 使用内置函数,内置函数可以不用加逗号
t5=tuple(('name'))
print(type(t5))
# 创建空的元组
t6=()
t7=tuple()
print(t6)
print(t7)

# 为什是不可以变的元组：在多任务环境下操作防止错误

# 元组的遍历
for item in t1:
    print(item)

四、集合：

1、集合的创建以及简单操作：

# 第一总创建方式,里面元素不可以重复且无序
s1={1,2,3,4,4}
print(s1)
# 第二种创建内置函数set（）
s2=set({1,2,3})
s3=set((1,2,3))
s4=set(range(6))
s5=set([1,2])
s6=set('hello')
print(s2)
# 元素是否在集合的判断
print(1 in s3)
print(1 not in s3)
# 添加元素
# 添加一个
s3.add(4)
print(s3)
# 添加多个，可以是集合，元组，列表
s3.update({1,9,0})
print(s3)
# 删除
# 删除一个元素，如果不存在会报错
s3.remove(1)
print(s3)
# 删除一个元素，如果不存在不会报错
s3.discard(100)
# 随机删除一个元素
s3.pop()
# 清空
s3.clear()

2、集合之间的操作：

s1 = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}

print(s1 == s2)  # 是否相等，true
print(s1 != s2)  # 是否相等，false

s3 = {10, 20, 60, 70}
s4 = {10, 20, 50}
s5 = {50, 60}
print(s3.issubset(s1))  # 是否是子集  true
print(s4.issubset(s1))  # 是否是子集  false

print(s3.issuperset(s1))  # 是否是超集，false
print(s1.issuperset(s3))  # 是否是超集， true

print(s3.isdisjoint(s1))  # 是否有交集，返回false代表有交集
print(s5.isdisjoint(s1))  # 是否有交集，返回true代表没有交集

# 求交集两个集合
print(s3.intersection(s4))
# 可以直接使用&符号
print(s3 & s4)

# 求两个集合的并集
print(s3.union(s4))
# 可以使用|
print(s3 | s4)

# 求两个集合的差集
print(s4.difference(s3))
# 可以使用符号-代替
print(s4 - s3)

#  求两个集合的对称差集
print(s4.symmetric_difference(s3))
# 可以使用^代替
print(s4 ^ s3)

五、字符串：

1、字符串的常规操作：

s='Hello'
# 字符串的查找(出现的第一个位置的index)
print(s.index('l')) #正序查找，如果查找不到会报错
print(s.rindex('l')) #倒序查找，如果查找不到会报错
print(s.find('l')) #正序查找，查不到会返回-1
print(s.rfind('l')) #倒序查找，查不到会返回-1

# 字符串的大小写转换，原来字符串不变
a=s.upper() #转大写
print(a)
b=a.lower() #全部转小写
print(b)
c=s.swapcase()
print(c) #大写转小写，小写转大写
d=c.title() #首字母大写
print(d)

# 字符串的对齐操作
print(s.center(20,'*'))# 居中对齐，两个参数，第一个是长度，第二个是填充符号（第二个参数不填是默认空格,如果长度不足则返回原字符串
print(s.ljust(20,'*'))# 左对齐，两个参数，第一个是长度，第二个是填充符号（第二个参数不填是默认空格,如果长度不足则返回原字符串
print(s.rjust(20,'*'))# 右对齐，两个参数，第一个是长度，第二个是填充符号（第二个参数不填是默认空格,如果长度不足则返回原字符串
print(s.zfill(20))# 右对齐，两个参数，第一个是长度，第二个是填充符号（第二个参数不填是0,如果长度不足则返回原字符串

# 字符串的分割,不填默认是以空格分割
q='hello python'
lst=q.split() #正切割
print(lst)

w='hello|python'
lst1=w.rsplit('|') #反着切割
print(lst1)

2、字符串的判断以及格式化字符串：

s = 'ls1'
print(s.isidentifier())  # 是否是由合法的标示符号组成
a = ' \n '
print(a.isspace())  # 是否是全部由空白字符串组成 （回车，空格，换行，水平制表符号）
d = 'qwe都是'
print(d.isalpha())  # 是否是由字母（包括汉字）组成
f = '2二'
print(f.isdecimal())  # 是否由十进制数字组成
g = '二'
print(g.isnumeric())  # 是否由数字组成，包括汉字数字，罗马数字
de = 's是二'
print(de.isalnum())  # 是否由数字和字母（包括汉字）
q = '我是你我是你'
print(q.replace('我', '你'))  # 替换，第三个参数是替换个数，不填默认是所有
r = {'wo', 'shi', 'ni', 'die'}
t = '*'
print(t.join(r))  # 拼接，返回是  ni*shi*die*wo
# 字符串比较由>,>=,<,<=他们都是比较的asci值，最多使用的==和！=就是比较值的内容是否相同
print('qweq' == 'qwe')
# 字符串的切片
p = 'hello,world'
print(p[0:5:1])
# 格式化字符串
print('我是%s,年龄%i' % ('lg', 18))  # %s代表字符串，%i、%d代表整数，%f代表小树
print('我是{0},年龄{1},我真是{0}'.format('lg', 18))  # {}代表占位符

name = 'lg'
age = 18
print(f'我是{name}，年龄{age}，我真是{name}')
print('%10s' % ('1')) #代表宽度10
print('%10.3f' % (3.1314)) #代表小数点后面三位，总宽度是10
print('{0:10.3f}'.format(1111.11111)) #代表小数点后面三位，总宽度是10,加f代表小数点后面三位数字，不加就代表3位

i='八格牙路'
byte=i.encode('GBK')#编码
print(byte)
print(byte.decode('GBK'))#解码

        今天偷懒了一下，单纯的把之前写的cv过来了（自己也看了一遍算是温习下吧）。工作繁忙了一丢丢。