Python学习之序列

序列:一个或者多个具有相同特征的元素构成的集合

字符串:'sss'   或者 “sss"

列表: []

元组()


字典{}



序列的通用操作:

1,索引

2,切片

[m,n,k]

取出序列中元素,这些元素的索引满足条件是  在区间  [m,n),且步长为k的元素

即获取的元素索引值为

m,m+k,m+2*k      ,……              

:k为负数,则是从后往前取

代码示例:

# 切片  [m,n,k]  选取索引   在【m,n) 的元素,步长是   k
#   m  ,m+k,m+2k
# m默认值是0,n默认值是最后一个元素的索引,k默认为1
array=[1,2,3,4,5,6,7,8]
#输出索引在[1,3)的子序列
print(array[1:3])#[2, 3]
print(array[1:])#[2, 3, 4, 5, 6, 7, 8]
print(array[4:])#[5, 6, 7, 8]
print(array[1:8:2])#[2, 4, 6, 8]
# 倒序输出
print(array[::-1])
#  m默认值是0,n默认值是最后一个元素的索引,k默认为1
print(array[::])


3,加法   两种相同的序列可以进行加法操作(字典不支持)

以列表为例

list1=[1,2,3,4]

list2=[5,6,7]

list3=list1+list2

list3结果为[1,2,3,4,5,6,7]

4 乘法,

print([1,2,3]*2)#[1, 2, 3, 1, 2, 3]

5,成员资格

    item  in sequence  返回值是bool

print(1 in [1,2,3])#True

6,最大值,最小值,长度

max(sequence)

min(sequence)

len(sequence)

list2=[6,7,8,9,10]
print(max(list2))#10
print(min(list2))#6
print(len(list2))#5

1,字符串:


字符串是0个或多个字符组成的序列


# 1,表示方法

    #由一对单引号或者双引号表示,仅表示单行字符串
print ('hello world '
         '这是一行字符串')
    #由一对三单引号,可以表示多行字符串
print ('''z这是多行字符串 第一行
             第二行''')
        #三单引号并不是说的多行注释符号(python 也没有多行注释符号),只是表示字符串,如果没将该字符
        #符串赋值给变量,那么程序则视为注释,不加以处理
'''hello 这是注释'''

#上面两种方式可以看出前者 只有一行的,后者是多行
testString="0123456789"
'''2  索引: <串>[]  获取单个字符'''


'''3 切片操作 <串>[M:N] 
M缺失,表示到开头   N缺失表示到结尾    M和N都缺失表示到开头和到结尾'''
print("[:3]  "+testString[:3])
print("[3:]  "+testString[3:])
print("[:]  "+testString[:])
'''3* 高级操作 <串>[M:N:K]  K表示步长 '''
print("[0::2]  "+testString[0::2])
print("[::2]  "+testString[::2])
#步长为-1 表示从后向前,步长为1
print("[::-1]  "+testString[::-1])
print("[::-2]  "+testString[::-2])

#4  特殊字符  \   转意符  表达特定字符的本意
print("hello 转义 \n  换行了")
print("hello 转义 双引号 (\")  换行了")
      #表达不可打印的含义 \n换行  \b回退    \r   当前行行首
#5 字符串操作符   +  、  *   、x in  s  返回x是不是在s中
print("a"+"b")
print("a "*3)
#x in  s  返回x是不是在s中
print("a" in "abc")
print('a' in "abc")
#6  字符串处理函数  len(x)   str(x)//将变量变成字符串
lenString="123abc你"
print(len(lenString))
print(str(123))
print(str([1,2,3,4]))
  # hex(x)  将整数转为十六进制小写字符串
print(hex(425))
   # oct(x)  将整数转为八进制小写字符串
print(oct(425))
#chr(x)    x为unicode编码,返回其对应的字符
#ord(x)   x为字符,返回器对应的unicode编码
    #unicode编码是统一字符编码  ,每个编码对应一个编码,
    # python字符串中每个字符都是unicode编码字符
print("chr(x)   ord(x)")
# print(Str(chr(9801)))
print(ord(chr(100)))
for i in range(12):
    print (chr(9800+i))
# eval  将字符串的双引号去掉


# 字符串的特有操作
# 1,字符串与数字相互转换   str(),int(),float()
#,2,格式化输出
#     目标字符串
# 3,字符串操作函数
#    子串查找与替换   .find(sub),  .rfind(sub)   .replace(old,new)
#    查找子串的位置   str.index(sub)
#    统计元素出现的次数
#    裁掉特定字符的函数   str.lstrip([chars])
#                             str.rstrip([chars]),
#                            str.strip([chars])
strExample="www.baidu.  com"
print(strExample.lstrip('cmowz'))#.baidu.  com
print(strExample.rstrip('cmowz'))#www.baidu.
print(strExample.strip('cmowz'))#  .baidu.
print(strExample.strip())#www.baidu.  com
# 注意数据库中的char 与varchar  char会填充空格,于是从数据库取出char需要将空格去掉,才能够执行 == 比较
2,列表:[] ,元素可重复,类型可以不统一,变长

方法:

1,追加元素 . append(object)追加元素,

          .extend(sequence)一次性追加多个元素

2,删除元素 .remove(obj) 删除元素obj

                  .pop(index)删除索引是index的元素

3,排序   .sort()是内置的排序方法

               sorted(sequence,key=function,reverse=True||False)这是通用的给序列排序的方法,key的值是一个函数,返回排序的依据

                                 reverse指定排序是升序还是逆序(默认是升序,如果设置为True,则是降序)



#列表
# 支持序列的所有操作
# 方法   append(),
# extend(),


# remove(object),pop(index),   del  删除对象引用
# index()
# count()
L=['B','c']
# append是在后追加元素
# extend 函数用于在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)。
L.append("hello")#['a', 'c', 'B', 'c', 'hello']
print("after append 'hello'",L)
L.extend('HELLO WORLD')#['a', 'c', 'B', 'c', 'hello', 'H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']
print("after extend 'HELLO WORLD'--->",L)
ls2=['cc','dd']
L.append(ls2)



print("after append ['cc','dd']--->",L)
L.remove(ls2)
L.extend(ls2)
print("after extend ['cc','dd','ee']",L)
L.remove('D')

print("after remove element 'D'--->",L)
# L.exntend(L)#AttributeError: 'list' object has no attribute 'exntend'
# print("after extend itself----->",ls2)
L.pop(1)
print("after remove element where index is '1'--->",L)

# 排序 sort()

L.sort()
print(L)
# 注意:key参数的值应该是一个函数,
# 它接受一个参数并返回一个用于排序目的的键。
#  这种技术速度很快,因为每个输入记录只需要调用一次关键函数。
lst=sorted('H E L L O A B D C G E'.split(),key=str.upper)
print(lst)
#复杂对象的排序
student_tuple = [
    ('john','A',15),
    ('jane','B',12),
    ('dave','B',10),
]
lst1 = sorted(student_tuple,key=lambda student:student[2])   #按照年龄排序
print(lst1)   #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
lst1 = sorted(student_tuple,key=lambda student:student[2],reverse=True)   #按照年龄降序排序
print(lst1)#[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]



#复杂对象的排序:
class Student:
    def __init__(self,name,grade,age):
        self.name = name
        self.grade = grade
        self.age = age
    def __repr__(self):
        return repr((self.name,self.grade,self.age))
    def weighted_grade(self):
        return 'CBA'.index(self.grade)/float(self.age)
student_objects = [
    Student('johnn','A',15),
    Student('janee','B',12),
    Student('davee','B',10),
]
lst2 = sorted(student_objects,key=lambda student:student.age)
print(lst2)   #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

3,字典 {}   key要求类型相同,value类型不要求

说白了就是json格式,或者是相当于java中的map  key-value

例如: dict={'name':“张”,’性别‘:“男”}

1,取出所有key

.keys()

2,取出所有value

.values()

3,通过循环遍历value

#字典
dict={"name":"张","sex":"男"}
print(dict.keys())
print(dict.values())
for item in dict:#这里遍历得到的是key
    print(item)
    print("value:",dict[item])

4,取出键值对

print(dict.items())

注意:字典不支持 +操作

5,删除元素  .pop(key)通过key来删除

dict2={"address":"山东"}
print(len(dict2))
dict2.pop("address")
print("after pop 'address' ",dict2)

6,删除一个键值对

.popitem()#弹出最后的一个k-v键值对,以二元组的形式返回

D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.

dict3={1:"hello",2:"world",3:"python"}

for time in  range(len(dict3)):
    print(time)#循环次数
    print(dict3)#当前字典内容
    print(dict3.popitem())#弹出字典的item


4,元组   ()定长,类型相同,元素不能被修改

元素可以重复,但是不能被修改
1,相加操作  +

2,切片操作,见字符串

3,列表转为元组tuple(seq) 返回元组

#元组
tup1 = ('physics', 'chemistry', 1997, 2000,1997);
print(tup1)
print(tup1[0])
# 元素数量
print(tup1.count(1997))#2
tup2=()
tup3=("hello",)#一个元素时,这个都哈可以省略
#加操作
print(tup3+tup1)#('hello', 'physics', 'chemistry', 1997, 2000, 1997)
#序列转为元组
list=[1,2,3,4]
print(tuple(list))#(1, 2, 3, 4)

















阅读更多

扫码向博主提问

1622636762

非学,无以致疑;非问,无以广识
  • 擅长领域:
  • javaweb
  • 后端
  • linux
  • mysql
去开通我的Chat快问
版权声明:本文为博主原创文章,转载请注明原文链接 https://blog.csdn.net/qq_36922927/article/details/80694687
文章标签: sequence python
个人分类: python
上一篇线程之安全发布对象--单例模式
下一篇python之函数
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭