Python基础学习

1.可变字符串

     在Python中，字符串属于不可变对象，如果需要修改其中的值，只能创建新的字符串对象。但是可以用io.StringIO对象或array模块。

import io
s='good night'
sio=io.StringIO(s) #新生成的对象,字符串需要频繁修改
print(sio.getvalue())#good night
print(sio.seek(7))
print(sio.write('f'))
print(sio.getvalue())   #good nifht

2.基本运算符

   and、or、not布尔与或非

   is、is not判断是否为同一个对象

   <、>比较值是否相等

a=4
print(3<a<10)   #True 关系运算符可以连用

a=0b01101
b=0b10011
print(bin(a|b))    #0b11111 按位或并且保证输出为二进制
print(bin(a&b))   #0b1  按位与
print(bin(a^b))  #0b11110按位异或

a=3
print(a<<2)  #左移一位相当于乘2
print(a>>1)  #1  右移一位相当于除以2
b=8
print(b>>2)   #2

 3.序列

   序列：一种数据储存方式，用来储存一系列的数据。在内存中，序列就是一块用来存放多个值（对象的地址）的连续的内存空间。

  常用的序列结构：字符串、列表、元组、字典、集合。

  列表：用于存储任意数目，任意类型的数据集合。

  列表大小可变。字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素 的序列。

4.列表的创建

（1）基本语法的创建

a=[20,30,50,'xiaohong']
print(a[0])  #20
b=[]
b.append(10)
print(b)   #[10]

（2）list()创建：list()将任何可以迭代的数据转化为列表。

a=list('fuzhuoming')
print(a) #['f', 'u', 'z', 'h', 'u', 'o', 'm', 'i', 'n', 'g']
b=list(range(5))
print(b)  #[0, 1, 2, 3, 4]

  range()创建整数列表

   range[start,end,step]

c=list(range(0,10,2)) print(c) #[0, 2, 4, 6, 8]range()完整用法

（3）推导式生成列表 

a=list(x*2 for x in range(10))
print(a)  #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]对于0-9的所有数乘2
b=list(x*2 for x in range(100) if x%9==0)
print(b)  #[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]对于0-100中9的倍数乘2取出

 5.列表元素的增加和删除

  （1）append()方法:在列表尾部直接加元素

a=[10,20]
a.append('wo')
print(a) #[10, 20, 'wo']

a=[10,20,30]
a.append([12,14])
print(a) #[10, 20, 30, [12, 14]]
a.append(15,17)
print(a) #错误，append只能添加一个元素

 （2）+运算符操作：创建新的列表对象，将原来的列表元素复制到新的列表对象中。（不建议）

a=[10,20]
print(id(a))
a=a+[3,4] #2568250519936
print(a) #[10, 20, 3, 4]
print(id(a)) #2568245607744重新生成了列表

（3）extend():原地操作，不创建新的列表对象

a=[10,20,30]
print(id(a))  #2043085779328
a.extend([2,4])
print(a)   #[10, 20, 30, 2, 4]
print(id(a)) #2043085779328没有生成新的对象

 （4）insert():可以将指定元素插入到列表对象的指定位置。（不建议）

a=[10,20,30]
a.insert(2,100)
print(a)  #[10, 20, 100, 30]

  （5）乘法扩展 

a=[10]*3 
print(a) #[10, 10, 10]

6.列表元素的删除

（1）del删除

a=[100,200,888,300,400]
del(a[2])
print(a)

本质上是数组元素依次拷贝 

（2）pop()方法

a=[10,20,30,40,50]
b=a.pop()
print(b)  #50a中元素从末尾依次弹出
c=a.pop(1)
print(c) #20弹出指定元素
print(a)    #[10, 30, 40]a中元素被弹出后

（3）remove()：删除首次出现的指定元素。

a=[10,20,30,40,50]
a.remove(20)
print(a)  #[10, 30, 40, 50]

7.列表元素访问和计数

（1）通过索引直接访问元素

（2）获得指定元素在列表中首次出现的索引

      index(value,[start,end])

a=[10,20,30,20,50,60,70]
print(a.index(20))  #1
print(a.index(20,2))  #3

（3）count()获得指定元素在列表中出现的次数

a=[10,20,30,20,50,60,70]
print(a.count(20))#2

（4）len()列表长度

a=[10,20,30,20,50,60,70]
print(len(a))  #7

8.切片操作

  [起始偏移量：终止偏移量：步长]

a=[10,20,30,20,50,60,70]
print(a[:])  #[10, 20, 30, 20, 50, 60, 70]
print(a[1:3:1])  #[20, 30]
print(a[1::2])  #[20, 20, 60]
print(a[1::])  #[20, 30, 20, 50, 60, 70]
print(a[::-1])   #[70, 60, 50, 20, 30, 20, 10]
print(a[-5:-1])  #[30, 20, 50, 60]

列表的遍历

a=[10,20,30,20,50,60,70]
for x in a:
    print(x)
"""10
20
30
20
50
60
70 """

9.列表的排序

（1）修改源列表，不建立新列表

   a.sort()

a=[2,6,67,34,23,12,44]
print(id(a))  #2753240232320
a.sort()
print(a)  #[2, 6, 12, 23, 34, 44, 67]
print(id(a))  #2753240232320

随机顺序排列 

import random
a=[2, 6, 12, 23, 34, 44, 67]
random.shuffle(a)
print(a)  #[34, 23, 67, 2, 12, 6, 44]

（2）建新列表的排序

   a=sorted(a)

a=[10,30,20,40]
print(id(a))  #1706513330496
a=sorted(a)
print(a)      #[10, 20, 30, 40]实现升序排列
print(id(a))   #1706518229568 地址发生了改变，创建了新的列表

（3）reversed()返回迭代器 

a=[10,30,20,40]
c=reversed(a)
print(c)  #<list_reverseiterator object at 0x0000018298A16790>
print(list(c))  #[40, 20, 30, 10]得到降序排列，利用指针
print(list(c)) # []只能使用一次

（4）max()  min()  sum()用法 

a=[10,30,20,40]
print(max(a))  #40
print(min(a)) #10
print(sum(a))   #100

10.二维列表

a=[['张三',18,30000,'北京'],['李四',19,10000,'上海'],['王五',20,15000,'成都']]
for m in range(3):
    for n in range(4):
        print(a[m][n],end="\t")
    print()
"""
张三	18	30000	北京	
李四	19	10000	上海	
王五	20	15000	成都	
"""

 11.元组tuple

     列表属于可变序列，可以任意修改列表中的序列。元组属于不可变序列，不能修改元组中的元素。所以，元组中没有增加元素，修改元素，删除元素相关的方法。

元组的创建

（1）通过（）创建，小括号可以省略。

a=(10,20,30)
print(type(a))  #<class 'tuple'>
b=1,2,3
print(type(b))  #<class 'tuple'>
c=(1)
print(type(c))  #<class 'int'>
c=(1,)
print(type(c))  #<class 'tuple'>

（2）通过tuple()创建元组。将字符串，range（）序列，列表转化为元组。

a=tuple('sacdsvdfb')
b=tuple(range(10))
c=tuple([12,14,25,46,87])
print(a)  #('s', 'a', 'c', 'd', 's', 'v', 'd', 'f', 'b')
print(b)  #(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(c)  #(12, 14, 25, 46, 87)

（3）元组的删除

del a

12.元组的元素访问和计数

a=tuple('sacdsvdfb')
print(a)  #('s', 'a', 'c', 'd', 's', 'v', 'd', 'f', 'b')
print(a[1:8:2])  #('a', 'd', 'v', 'f')

元组排序 

a=(29,3,54,58,23,10)
print(sorted(a))  #[3, 10, 23, 29, 54, 58]升序排列并且返回的是列表

zip():将多个列表对应位置的元素组合成为元组，并返回这个zip对象。 

a=[12,23,34]
b=[10,20,30]
c=[1,2,3,]
d=zip(a,b,c)
print(type(d))   #<class 'zip'>
print(d)     #<zip object at 0x00000206F65D4040>
print(list(d))  #[(12, 10, 1), (23, 20, 2), (34, 30, 3)]

13.生成器推导式创建元组

    生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

s=(x*2 for x in range(5))
print(s)  #<generator object <genexpr> at 0x00000184C9DFB9E0>生成器（只能用一次，是指针）
print(tuple(s))   #(0, 2, 4, 6, 8)

s=(x*2 for x in range(5))
s.__next__()   #令指针向后移动
s.__next__()
print(tuple(s))  #(4, 6, 8)