python基础知识-04-字符串列表元组

最新推荐文章于 2022-09-16 22:38:09 发布

weixin_34082695

最新推荐文章于 2022-09-16 22:38:09 发布

阅读量173

点赞数

原文链接：http://www.cnblogs.com/machangwei-8/p/10636141.html

版权

python其他知识目录

内存，cpu，硬盘，
解释器实时翻译编译器：一次性翻译
python2,3 除法，2不能得小数，3能得小数

1、字符串操作

1.1字符串操作startswith

startswith #判断是否以什么开头
name="mcw"
name_new=name.startswith("m")
print(name_new)
-------结果：
True

name="mcw"
name_new=bool(name[0]=="m")
print(name_new)
--------结果：
True

1.2字符串操作endswith

endswith #判断是否以什么结尾

name="mcw"
name_new=name.endswith("m")
print(name_new)
-------结果：
False

1.3字符串操作format

format() #格式化输出 %s可替代

网络传输gbk,不用Unicode。

1.4字符串操作encode

参考：https://blog.csdn.net/m0_38080253/article/details/78841280

encode #改变编码类型，网络传输和存储可以用到

name="mcw"
name_new=name.encode()
print(name_new)
--------结果：
b'mcw'

mcw="魔降风云变"
mcw_utf8 = mcw.encode("utf-8")
mcw_gbk = mcw.encode("gbk")
mcw_gb2312 = mcw.encode("gb2312")
print(mcw)
print("utf-8编码： ", mcw_utf8)
print("gbk 编码: ", mcw_gbk)
print("gb2312编码: ", mcw_gb2312)
print("utf-8 解码： ", mcw_utf8.decode('utf-8'))
print("gbk 解码: ", mcw_gbk.decode('gbk'))
print("gb2312 解码: ", mcw_gb2312.decode('gb2312'))

-----------结果：

魔降风云变
utf-8编码： b'\xe9\xad\x94\xe9\x99\x8d\xe9\xa3\x8e\xe4\xba\x91\xe5\x8f\x98'
gbk 编码: b'\xc4\xa7\xbd\xb5\xb7\xe7\xd4\xc6\xb1\xe4'
gb2312编码: b'\xc4\xa7\xbd\xb5\xb7\xe7\xd4\xc6\xb1\xe4'
utf-8 解码：魔降风云变
gbk 解码: 魔降风云变
gb2312 解码: 魔降风云变

错误之一：UnicodeDecodeError: 'gb2312' codec can't decode byte 0x94 in position 2: illegal multibyte sequence

原因：编码解码方式不一致

mcw="魔降风云变"
mcw_utf8 = mcw.encode("utf-8")
print("gb2312 解码: ", mcw_utf8.decode('gb2312'))

1.5、字符串操作join指定分隔符给字符串，列表，元组，因为内部会给它for 循环

join "_".join（name）#循环单个字符并添加分隔符，包括添加空格

name="mcw"
name_new="_".join(name)
print(name_new)
--------结果：
m_c_w

列表元组元素拼接，"".join(列表或元组)
li=["mcw","xiaoma","wl"]
mcw="_".join(li)
print(mcw)
---------结果：
mcw_xiaoma_wl

tup=("mcw","xiaoma","wl")
mcw="_".join(tup)
print(mcw)
------------结果：
mcw_xiaoma_wl

# ------------------join里边传的必须是字符串，否则报错---------
nums=[11,22,33,44]
num="".join(nums)
print(num)
-------结果：
TypeError: sequence item 0: expected str instance, int found

解决办法：

nums=[11,22,33,44]
for i in range(0,len(nums)):
    nums[i]=str(nums[i])
num="+".join(nums)
print(num)

-----------结果:
11+22+33+44

1.6、字符串反转操作以及实现正反序列的列表元素生成（延伸方法：五种方法实现字符串反转 name = "我叫小马过河博客是魔降风云变"）

步长，可正可负，切片。[-1:0:-1]
请将字符串反转：name[::-1]

name="mcwlllsf"
print(name[::-1])
#fslllwcm
name="mcwlllsf"
print(name[-1::-1])
#fslllwcm

请用五种方法实现字符串反转 name = "我叫小马过河博客是魔降风云变"（步长、while、for）
#既然字符串可以反转，那么字典，元组，列表怎么反转呢，思考一下

                                    #方法一---------------------

name = "我叫小马过河博客是魔降风云变"     
print(name[::-1])
----------以下结果都为：
变云风降魔是客博河过马小叫我

                                   #方法二---------------------

name = "我叫小马过河博客是魔降风云变"      
index=0
e_str=""                         #什么情况定义空字符串，或是列表，元组，字典
while index<len(name):
    index += 1
    e_str+=name[len(name)-index]
print(e_str)

                                 #方法三-------------------思路：倒着取出每个字符并拼接成字符串

name = "我叫小马过河博客是魔降风云变"      
e_str=""
for index in range(0,len(name)):
    e_str+=name[len(name)-index-1]
print(e_str)

                                    #方法四------------------

name = "我叫小马过河博客是魔降风云变"    
e_str=""
for index in range(len(name)-1,-1,-1):     #因为字符串索引最大值是字符串长度-1，range（）取

左值，所以起始值为len()-1
    e_str+=name[index]
print(e_str)

                                  #方法五-----------------#索引最大，倒着数

name = "我叫小马过河博客是魔降风云变"   
index=len(name)
e_str=""
while index>0:
    index-=1
    e_str+=name[index]
print(e_str)

实现正反序列的列表元素生成

正向序列：
li=[]
for i in range(0,3):
    li.append(i)
print(li)
---------结果：
[0, 1, 2]

反向序列
li=[]
for i in range(0,3):
    li.insert(0,i)
print(li)
-----------结果：
[2, 1, 0]

1.7、字符串一个切片操作案例

name="56+78"
a=name.split("+")          #指定分隔符
print(a,a[0],a[-1],a[1])   
['56', '78'] 56 78 78

1.8、字符串extend的操作

# 列表extend元组，列表
                           #列表.extend(元组)-------------
li=["mcw","xiaoma","wl"]
tup=("y","h","feng")
li.extend(tup)
print(li)
-----------结果：
['mcw', 'xiaoma', 'wl', 'y', 'h', 'feng']
                        #列表.extend(字符串)-------------                      
li=["mcw","xiaoma","wl"]
mcw_str="yh"
li.extend(mcw_str)
print(li)
------------结果：
['mcw', 'xiaoma', 'wl', 'y', 'h']
                        #列表.extend(列表)---------------
li=["mcw","xiaoma","wl"]
li2=["xiaoming","xiaoxiao"]
li.extend(li2)
print(li)
-------------------结果：
['mcw', 'xiaoma', 'wl', 'xiaoming', 'xiaoxiao']
                         #列表=列表+列表 多个列表元素合并
li=["mcw","xiaoma","wl"]
li2=["xiaoming"]
li=li+li2
print(li)
---------------结果：
['mcw', 'xiaoma', 'wl', 'xiaoming']
                        #列表.extend(字典)，默认将键加到列表后面。想加入其他，列表.extend(字典.keys/items/values)
li=["mcw","xiaoma","wl"]
dic={"name":"mcw","age":18}
li.extend(dic)
print(li)
-------------结果:
['mcw', 'xiaoma', 'wl', 'name', 'age']

2、#for循环打印字符串单个字符，for有限循环（while死循环）

name="mcwh"
for i in name:
print(i)
print(i) #因为最后一个被赋值h
--------结果：
m
c
w
h
h

#for中continue,break

3、range()

3.1range（0,3）取值范围：[0,3)

for i in range(0,3):
print(i)
-----结果：
0
1
2

for i in range(3):       #取值范围从0到3，不取3
print(i)
------结果：
0
1
2

for i in range(0,3):     
    print(2-i)           #使用range倒着来。（3-1）-i

-----------结果：

2
1
0

for i in range(0,5,2): #[0,1,2,3,4],取步长为2进行操作
print(i)
--------结果：
0
2
4

=======================shel序列号 =================

[root@xiaoma ~]# seq 3
1
2
3
[root@xiaoma ~]# seq 0 2
0
1
2
[root@xiaoma ~]# seq 0 2 5 #0-5，步长为2
0
2
4

3.2、range的一个使用案例（打印0-5之间的偶数）

for i in range(0,5,2):               #方法一
    print(i)

for i in range(0,5):                 #方法二
    if i%2==0:
        print(i)
------------结果：
0
2
4

#4、for循环1-10，不打印7

for i in range(1,11):
if i==7:                    #注解：for循环多少次结合range(),不打印7就是等于7就跳过
continue
print(i)

#重点，数据类型中的字符串
#for 循环

5、列表操作

mcw=list()                  #定义空列表，空列表布尔值为False
xiaoma=[]
print(mcw,bool(mcw),xiaoma)
---------------结果：
[] False []

5.1len

users=["mcw","yh",99]
val=len(users)
print(val)
------结果：
3

5.2索引和切片，步长（切片是一段字符）（查1）

users=["mcw","yh",99]
print(users[0],users[-1])
print(users[0:3])
print(users[::-1])
-----结果：
mcw 99
['mcw', 'yh', 99]
[99, 'yh', 'mcw']

5.3#输入数字+数字，实现求和

方法一
content=input("请输入：")
index=0
total=0
while True:
    char = content[index]
    if char.isdigit():
        total+=int(char)
    index+=1
    if index==len(content):
        break
print(total)
自我注解：
方法二：spilit

content=input("请输入数字+数字：")
sum=int(content.split("+")[0])+int(content.split("+")[1])
print(sum)

----------结果：

请输入数字+数字：16+4
20

5.4#for循环遍历列表（查2）

users=["mcw","yh",99]
for i in users:
    print(i)
-----结果：
mcw
yh
99

users=["mcw","yh","99"]
for i in users:
    for j in i:
        print(j)
----结果：
m
c
w
y
h
9
9
如果99是数字，出现报错

#自我注解：对多个事物做相同的操作，就用for循环，假如其中某个不做这个操作，用判断将它剔除

5.5#实现列表元素打印并加序号（查3）

#for循环列表加个计数的

方法一：
users=["mcw","yh","99"]
for i in range(0,len(users)):
    print(i,users[i])
-----结果：
0 mcw
1 yh
2 99
方法二：
users=["mcw","yh","99"]
count=0
for i in users:
    print(count,i)
    count+=1
------结果：
0 mcw
1 yh
2 99

列表独有功能

5.6#列表追加元素（增1）

users=[]
while True:
    name = input("请输入姓名：")
    users.append(name)
------效果：
请输入姓名：mcw
['mcw']
请输入姓名：yh
['mcw', 'yh']
请输入姓名：xiaoma
['mcw', 'yh', 'xiaoma']

users=[]
for i in range(0,3):
    name=input("请输入用户名和密码，逗号隔开：")
    users.append(name)
print(users)
-------结果：
请输入用户名和密码，逗号隔开：mcw,123
请输入用户名和密码，逗号隔开：yh,456
请输入用户名和密码，逗号隔开：xiaoma,789
['mcw,123', 'yh,456', 'xiaoma,789']
    print(users)

5.7#录入用户名和密码并校验

users=["mcw,123","xiaoma,456","xiaoxiao,789"]
denglu = input("请输入用户名进行登录：")
dpasswd = input("请输入密码：")
for val in users:
    if denglu==val.split(",")[0] and dpasswd==val.split(",")[1]:
        print("登录成功")
--------------结果：
请输入用户名进行登录：mcw
请输入密码：123
登录成功

5.8#列表插入（增2）

users=["mcw","yh","99"]
users.insert(1,"xiaoma")
print(users)
-------结果：
['mcw', 'xiaoma', 'yh', '99']

5.9#列表元素移除：（删）

**ｒｅｍｏｖｅ移除元素

users=["mcw","yh","99"]
users.remove("yh")
print(users)
-------结果：
['mcw', '99']

**ｐｏｐ移除接索引

users=["mcw","yh","99"]
users.pop(1)
print(users)
-----结果：
['mcw', '99']

users=["mcw","yh","99"] 
users.pop() #pop默认从后面删除
print(users)
－－－－－结果：
['mcw', 'yh']

users=["mcw","yh","99"]
users.clear()                  #clear清空列表
print(users)
－－－－结果：
[]

**del

users=["mcw","yh","99"]
del users[1]
print(users)
------结果：
['mcw', '99']

5.10修改列表元素,以及元素内部元素（改）

注意点，字符串本身不能修改或删除，字符串是不可变类型，列表是可变类型。

users=["mcw","yh","99"]
users[0]="xiaoma"
print(users)
--------结果：
['xiaoma', 'yh', '99']

users=["mcw","yh","99"]
print(users[0][1]) #定位user[0]元素的第二个字符。
------结果：
c

5.11、列表操作expend（增3）

li=["xiao"]
s="mcw"
li.extend(s)
print(li)
------------结果：
['xiao', 'm', 'c', 'w']

li=["xiao"]
s="mcw"
li=li+" ".join(s).split()
print(li)
---------------结果
['xiao', 'm', 'c', 'w']

5.12、#将列表后面的值移到前面，pop删除的元素可用变量接收（删，增）

deleted=li.pop
li.append(deleted)

li=["mcw","xiaoma","wl"]
deleted=li.pop()
li.insert(0,deleted)
print(li)
---------结果：
['wl', 'mcw', 'xiaoma']

#增加： del 仅仅是删除，pop还能将删除后的赋予给一个变量

5.13、同样列表元素数量相同的变量在等号左边接收右边列表才没有问题

mcw=["mcw","xiaoma"]
a,b=mcw
print(a)
print(b)
--------------------结果：
mcw
xiaoma

5.14、reverse 列表元素反转

li=["mcw","xiaoma","xiaoxiao"]
li.reverse()
print(li)
----------结果：
['xiaoxiao', 'xiaoma', 'mcw']

5.15、sort列表元素排序，默认从小到大

sort 列表 默认从小到大
li=[2,5,1,6]
li.sort()
print(li)
------------结果：
[1, 2, 5, 6]

sort(reverse=Ture)  从大到小
li=[2,5,1,6]
li.sort(reverse=True)
print(li)
-----------结果：
[6, 5, 2, 1]

5.16#总结：

列表元素操作
增： append / insert
删： remove / pop / clear / del users[2]
改： users[3] = "新值"
查：索引/切片
列表嵌套：

users=["mcw",["xiaoming","xiaohong"],"99"]
print(users[1][1][4:])
-------结果：
hong

6、元组的书写规范

users=[11,"mcw","xiaoma"] #列表，可变类型
users=(11,"mcw","xiaoma") #元组，不可变类型
拥有公共功能：
索引（排除）
切片
步长
删除
修改
for循环
len
。。。。

6.1元组操作

users=("mcw","xiaoma","mojiangfengyunbian")
print(users[1],users[1:])
print(users[-1][::2])
print(len(users),len(users[-1]))
-----结果：
xiaoma ('xiaoma', 'mojiangfengyunbian')
mjageguba
3 18

6.2#特殊：元组中的元素不可被修改/删除

users=("mcw","xiaoma","mojiangfengyunbian")
users[0]="ff"
print(users)
--------结果：
TypeError: 'tuple' object does not support item assignment

# 示例一：
v1 = (11,22,33)
v1[1] = 999 # 错误
v1 = 999 # 正确
# 示例二：可以嵌套
v1 = (11,22,33,(44,55,66),(11,2,(99,88,),3))
# 示例三：嵌套
v2 = [11,22,33,(11,22,33)]
v2[-1][1] = 99 # 错误
v2[-1] = 123 # 正确
# 示例四：嵌套
v3 = (11,[1,2,3],22,33)
v3[1] = 666 # 错误
v3[1][2] = 123

#自我注解：可以修改的用列表，不可以修改的用元组，部分可以修改部分不可以修改的用元组和列表相
互嵌套

------
-------------

7、git相关使用

问题:
#开发流程：
1、写出你常用的git命令
2、你们公司是怎么用git做开发的
　　1）在码云或GitHub等代码托管的网站上创建自己的仓库。创建完之后码云会给我们一个仓库地址。
　　2）在本地自己写代码
　　3）将代码提交到远程仓库。
　　　　-初始化
　　　　-进入任意文件夹，
　　　　-git init
　　　　-git config 邮箱
　　　　-git config 姓名
　　　　-git remote add origin 仓库域名 #origin,给远程仓库域名起别名origin。
　　　　注意：至此，git已经将目录管理起来了，以后目录内文件有任意变化，git都能识别出来
　　-代码收集并提交
　　　　-git status #可以查看修改记录
　　　　-git add .
　　　　-git commit -m "注释"
　　　　-git push origin master #将本地仓库的代码同步到远程仓库
　　-在本地修改代码或删除文件等
　　　　-git add .
　　　　-git commit -m "注释"
　　　　-git push origin master #将本地仓库的代码同步到远程仓库
　　-[避免]如果远程仓库有本地没有的代码，必须先执行[可能引发合并的问题]
　　　　-git pull origin master
　　　　-git status #可以查看修改记录
　　　　-git add .
　　　　-git commit -m "注释"
　　　　-git push origin master #将本地仓库的代码同步到远程仓库