正文

我的Python之旅第二天

IP云
IP云V管理员/6 阅读
11/30
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一 、字符串操作

1单引号('')、双引号（""）、三引号（""" """）的区别。

如果字符串中不包含单引号、双引号，则三个引号没有区别。 

msg1="Today is a nice day,everyday is a new day"

print(msg1)

Today is a nice day,everyday is a new day

如果字符串中包含单引号，则应使用双引号或者三引号。 

msg2="My name is Alex,I'm 18 years old"

print(msg2)

结果为：My name is Alex,I'm 18 years old

如果字符串中包含多行、或者有双引号，则必须使用三引号。 

poem="""

登鹳雀楼

作者：王之涣

白日依山尽，黄河入海流。

欲穷千里目，更上一层楼。

"""

print(poem)

结果为： 

登鹳雀楼

作者：王之涣

白日依山尽，黄河入海流。

欲穷千里目，更上一层楼。

2字符串拼接（字符串加法） 
msg3='小明，早上 '

msg4='好'

print(msg3+msg4)

结果为： 

小明，早上 好

3字符串乘法

字符串*n，相当于把最字符串输出n次。 

msg3="哈哈"

print(msg3*2)

结果为： 

哈哈哈哈

4字符串索引取值

str='pneumonoultramicroscopicsilicovolcanoconiosis'

取索引为0的字符，既就是字符串中的第一个字符 

s1=str[0]

print(s1)

print(s1,type(s1))

结果： 

p

p <class 'str'>

取索引为2的字符 

s2=str[2]

print(s2)

结果：e

取字符串最后一个字符，可正向数，但是字符串很长的话，就不现实。 

s3=str[-1]

print(s3)

结果：s

取倒数第四个字符 

s4=str[-4]

print(s4)

结果为：o

5字符串切片

str='pneumonoultramicroscopicsilicovolcanoconiosis'

注意：切片顾头不顾尾

取前四个字符，既就是索引为0-3的字符 

s5=str[0:4]

print(s5)

结果：pneu

取前6个字符： 

s6=str[:6]

print(s6)

结果为：

pneumo

取所有字符 

s7=str[:]

print(s7)

结果为：

pneumonoultramicroscopicsilicovolcanoconiosis

按步长取字符

取索引为1、3、5、7、9字符 

s8=str[1:10:2]

print(s8)

结果为：nuool

取索引为0、2、4…..16的字符 

s9=str[0:16:2]

print(s9)

结果为：pemnutai
print(str[14])
结果为：i

说明：由于切片顾头不顾尾，所以索引为0-16，取补偿为2，最后的一个字符是索引为14的字符。

切片：s[起始索引:结束索引+1:步长]

6字符串的常用方法

（1）首字母大写其余全小写 capitalize() 

str='iammlearningPython'

s1=str.capitalize()

print(s1)

结果为：Iammlearningpython

（2）字符大小写翻转 swapcase() 

str='IammLearningPythoN'

s2=str.swapcase()

print(s2)

结果为：iAMMlEARNINGpYTHOn

（3）非字母隔开的每个单词的首字母大写 title() 

str='I am learning pythoN'

s3=str.title()

print(s3)

结果为：I Am Learning Python
str1='I am learning*pythoN'

s4=str1.title()

print(s4)

结果为：I Am Learning*Python

（4）设置字符串总长度，并居中center()

设置总长度为20并居中 

str='title'

s5=str.center(20)

print(s5)

结果为： title

用其他字符填充并居中 

str='title'

s6=str.center(20,'=')

print(s6)

结果为：=======title========

（5）字符串全大写 upper() 

str='aadgUOHYasadsg'

s7=str.upper()

print(s7)

结果为：AADGUOHYASADSG

（6）字符串全小写 lower() 

str='aadgUOHYasadsg'

s8=str.lower()

print(s8)

结果为：aadguohyasadsg

（7）去除字符串前后的空格，换行符，制表符 strip() 

str=' helloHello\t'

s9=str.strip()

print(s9)

结果为：helloHello

lstrip(),rstrip()分别为去除左边和右边的空格、换行符、制表符。

字符的替换 replace 

str="wang ma zi"

s10=str.replace('a','b')

print(s10)

结果为：wbng mb zi

只替换指定次数 

str="wang ma zi"

s11=str.replace('a','b',1)

print(s11)

结果为：wbng ma zi

（8）分隔 split

默认以空格分隔 

str='Hello box apple'

s1=str.split()

print(s1)

结果为：['Hello', 'box', 'apple']

指定分隔符"," 

str2='Hello,box,apple'

s2=str2.split(',')

print(s2)

结果为：['Hello', 'box', 'apple']

字母为分隔符进行分隔 

str3='Helloboxapple'

s3=str3.split('b')

print(s3)

结果为：['Hello', 'oxapple']

按字母为分隔符，并指定分隔次数 

str4='Helloboxapple'

s4=str4.split('o',2)

print(s4)

结果为：['Hell', 'b', 'xapple']

（9）join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串

序列为元组 

str = "-"

seq = ("a", "b", "c")

s11=str.join(seq)

print(s11)

结果为：a-b-c

序列为列表 

l1 = ['alex', 'wusir', 'ritian']

s10 = '__'.join(l1)

print(s10,type(s10))

结果为：alex__wusir__ritian <class 'str'>

（10）通过元素找索引 find、index

find 找不到返回-1

index找不到会报错 

str="abcdefghigklmn"

f1=str.find('e')

print(f1)

结果为：4
str="abcdefghigklmn"

f2=str.find('r')

print(f2)

结果为：-1
str="abcdefghigklmn"

i1=str.index('h')

print(i1)

结果为：7
str="abcdefghigklmn"

i1=str.index('r')

print(i1)

结果为：

……

i1=str.index('r')

ValueError: substring not found

（11）测量字符串长度 len() 

str="asdgaggettetew"

s1=len(str)

print(s1)

结果为：14

（12）统计字符出现的次数 count() 

str="asdgaggettetew"

s2=str.count('t')

print(s2)

结果为：3

（13）判断字符串是否由字母或数字组成 isalnum() 

str="3512asdgag"

s1=str.isalnum()

print(s1)

结果为：True

（14）判断字符串是否由字母组成 isalpha() 

str="3512asdgag"

s2=str.isalpha()

print(s2)

结果为：False

（15）判断字符串是否由数字组成 isdigit() 

str=""

s3=str.isdigit()

print(s3)

结果为：True

7 字符串格式化
  1. 第一种方法，用format进行格式化，按给的的顺序赋值。 
str="我叫{}，今年{}，爱好{}"

s1=str.format('张三','','篮球')

print(s1)

结果为： 我叫张三，今年18，爱好篮球
  1. 第二种方法，指定索引，按索引赋值。 
str="我叫{0}，今年{1}，爱好{2},我就是{0}"

s2=str.format('李四','','跑步')

print(s2)

结果为：我叫李四，今年19，爱好跑步,我就是李四
  1. 第三种方法，按变量赋值 
str="我叫{name}，今年{age}，爱好{hobby}"

s3=str.format(age=30,hobby='旅游',name='王麻子')

print(s3)

结果为：我叫王麻子，今年30，爱好旅游

二 、格式化输出、运算符

1 格式化输出 % ，占位符 s d，

第一种方法： 

name=input("请输入姓名：")

age=input("请输入年龄：")

job=input("请输入职业：")

hobby=input("请输入爱好：")

msg='''----------info of %s-------------

Name: %s

Age: %d

Job: %s

Hobby: %s

---------------End--------------

'''%(name,name,int(age),job,hobby)

print(msg)

运行结果：

请输入姓名：李四

请输入年龄：10000

请输入职业：程序员

请输入爱好：不知道

----------info of 李四-------------

Name: 李四

Age: 10000

Job: 程序员

Hobby: 不知道

---------------End--------------

第二种方法 

print("我是%s,今年%d,学习进度30%%" % ('王麻子',1000))

我是王麻子,今年1000,学习进度30%

2逻辑运算符 and or not

（1）前后都是比较运算

优先级：() > not > and > or 

print(1>2 and 3<4 or 4>5 and 2>1)

结果为：False

（2）前后都是数值

0 是False ，非0 都是True 

x or y if x is True,return x
print(0 or 1)

结果为：1
print(3 or 1)

结果为：3
print(0 or -5)

结果为：-5
print(-4 or 8)

结果为：-4

三 、列表

1列表的取值

（1）按索引取值，取出来与元素本身的数据类型一致 

li=[1,2,(5,4,3),9,4,0]

l1=li[1:8]

print(l1)

结果为：[2, (5, 4, 3), 9, 4, 0]
li=[1,2,(5,4,3),9,4,0]

l2=li[2]

print(l2)

结果为：(5, 4, 3)

（2）按切片取值，取出来的是小列表 

li=[1,2,(5,4,3),9,4,0]

l3=li[0:3]

print(l3)

结果为：[1, 2, (5, 4, 3)]

2 列表的增加

（1）追加 append() 

lis=['zhangsan','lisi','sunwukong']

list1=lis.append('zhubajie')

print(lis)

结果为：['zhangsan', 'lisi', 'sunwukong', 'zhubajie']

（2）按索引插入 inset() 

lis=['zhangsan','lisi','sunwukong']

list2=lis.insert(1,'zhubajie')

print(lis)

结果为：['zhangsan', 'zhubajie', 'lisi', 'sunwukong']

（3）extend

list.extend(sequence) 把一个序列seq的内容添加到列表中 

lis=['zhangsan','lisi','sunwukong']

abc=[1,2,3]

lis.extend(abc)

print(lis)

结果为：['zhangsan', 'lisi', 'sunwukong', 1, 2, 3]

3 列表的删除

（1）按照索引删除 pop()

不知道索引，Python3.5以后版本默认删除最后一个元素 

lis=['zhangsan','lisi','sunwukong','duanyu']

lis.pop()

print(lis)

结果为：['zhangsan', 'lisi', 'sunwukong']

指定索引，并删除 

lis=['zhangsan','lisi','sunwukong','duanyu']

lis.pop(1)

print(lis)

结果为：['zhangsan', 'sunwukong', 'duanyu']

（2）按照元素去删除 remove() 

lis=['zhangsan','lisi','sunwukong','duanyu']

lis.remove('lisi')

print(lis)

结果为：['zhangsan', 'sunwukong', 'duanyu']

（3）按切片删除 del 

lis=['zhangsan','lisi','sunwukong','duanyu']

del lis[0:2]

print(lis)

结果为：['sunwukong', 'duanyu']

（4）清空列表 clear() 

lis=['zhangsan','lisi','sunwukong','duanyu']

lis.clear()

print(lis)

结果为：[]

4 列表的修改

（1）按照索引修改 

lis=['zhangsan','sunwukong','duanyu','shipotian']

lis[0]='王麻子'

print(lis)

结果为：['王麻子', 'sunwukong', 'duanyu', 'shipotian']

（2）按照切片去修改

按切片修改是会吧切片当成一个元素处理，把给定的字符串当做多个字符分别处理 

lis=['zhangsan','sunwukong','duanyu','shipotian']

lis[0:3]='dingdian'

print(lis)

结果为：['d', 'i', 'n', 'g', 'd', 'i', 'a', 'n', 'shipotian']
lis=['zhangsan','sunwukong','duanyu','shipotian']

lis[1:3]='abc'

print(lis)

结果为：['zhangsan', 'a', 'b', 'c', 'shipotian']

（3）加步长，必须意义对应 

lis=['zhangsan','sunwukong','duanyu','shipotian']

lis[0:3:2]='ab'

print(lis)

结果为：['a', 'sunwukong', 'b', 'shipotian']，既就是把索引为0的元素修改为"a"、索引为2的元素修改为"b"。

5 列表的查找

（1）按照索引查找 

lis=['zhangsan','sunwukong','duanyu','shipotian']

print(lis[1])

结果为：sunwukong

（2）按照切片查找 

lis=['zhangsan','sunwukong','duanyu','shipotian']

print(lis[1:3])

结果为：['sunwukong', 'duanyu']

（3）按照切片加步长查找 

lis=['zhangsan','sunwukong','duanyu','shipotian','renwoxing']

print(lis[1:4:2])

结果为：['sunwukong', 'shipotian']

（4）遍历列表 for 

lis=['zhangsan','duanyu','shipotian','renwoxing']

for i in lis:

print(i)

结果为：

zhangsan

duanyu

shipotian

renwoxing

（5）列表总长度 len() 

lis=['zhangsan','duanyu','shipotian','renwoxing']

print(len(lis))

结果为：4

（6）统计列表中某个元素出现的次数 count() 

lis=['zhangsan','rw','duanyu','shipotian','rw']

print(lis.count('rw'))

结果为：2

（7）正序排列 sort() 

list1=['','','','','',]

list1.sort()

print(list1)

结果为：['', '', '', '', '']

（8）倒叙排列 list.sort(reverse=True) 

list1=['','','','','',]

list1.sort(reverse=True)

print(list1)

结果为：['', '', '', '', '']

（9）列表的翻转 

list1=['','','','','',]

list1.reverse()

print(list1)

结果为：['', '', '', '', '']

6 列表的嵌套

（1）将yangguo变成Yangguo 

list1=['','','yangguo',['limochou','zhoubotong',1000],666]

list1[2]=list1[2].capitalize()

print(list1)

结果为：['', '', 'Yangguo', ['limochou', 'zhoubotong', 1000], 666]

（2）将"zhoubotong 全部变为大写" 

list1=['','','yangguo',['limochou','zhoubotong',1000],666]

list1[3][1]=list1[3][1].upper()

print(list1)

结果为：['', '', 'yangguo', ['limochou', 'ZHOUBOTONG', 1000], 666]

（3）通过数字减1 的方式将1000变为999 

list1=['','','yangguo',['limochou','zhoubotong',1000],666]

list1[3][-1]=str(list1[3][-1]-1)

print(list1)

结果为：['', '', 'yangguo', ['limochou', 'zhoubotong', ''], 666]

7 列表去重 
l1=[1,2,2,1,3,4,5]

print(list(set(l1)))

结果为：

[1, 2, 3, 4, 5]

四、元组

元组为只读列表

1 元组的读取

可按照索引、切片、切片加步长 

tuple1=(1,2,3,4,'linchong','likui')

print(tuple1[1])

print(tuple1[0:2])

print(tuple1[1:5:2])

结果为： 

 2

 (1, 2)

 (2, 4)

2 元组不可修改，但是元组里边可修改的元素却可以改 
tuple2=(1,2,3,[1,3,5],4)

tuple2[3].append(888)

print(tuple2)

结果为：(1, 2, 3, [1, 3, 5, 888], 4)

3 range() 函数可创建一个整数列表，一般用在 for 循环中

Python3.x 中 range() 函数返回的结果是一个整数序列的对象，而不是列表。 

print(range(4))

print(list(range(4)))

结果为：

range(0, 4)

[0, 1, 2, 3]

五、字典

1 字典的增加

（1）直接指定key、value，无则增加，有则修改。 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

dic['hobby']='美女'

print(dic)

结果为：{'name': '韦小宝', 'age': 20, 'sex': '男', 'hobby': '美女'}

（2）dic.setdefaulte() 有key则不修改，无责添加。 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

dic.setdefault('身高',180)

print(dic)

结果为：{'name': '韦小宝', 'age': 20, 'sex': '男', '身高': 180}
dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

dic.setdefault('age',180)

print(dic)

结果为：{'name': '韦小宝', 'age': 20, 'sex': '男'}

2 字典的删除

（1）按照键值删除 dic.pop()、del dic[key] 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

dic.pop('name')

print(dic)

结果为：{'age': 20, 'sex': '男'}

（2）随机删除 dic.popitem()

字典popitem()方法作用是：随机返回并删除字典中的一对键和值（项）。 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

dic.popitem()

print(dic)

结果为：{'name': '韦小宝', 'age': 20}

Python3.5后版本后默认删除最后一组键值对

（3）清空字典 dic.clear() 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

dic.clear()

print(dic)

结果为：{}

3 字典的查找

（1）按照键值查找 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

print(dic['name'])

结果为：韦小宝

（2） dic.get() 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

print(dic.get('age'))

结果为：20

如果键值输错了 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

print(dic.get('agei','没有。。。。'))

结果为：没有。。。。

（3）打印键和值，类似于列表的一个容器，没有索引。 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

print(dic.keys())

print(dic.values())

结果为：

dict_keys(['name', 'age', 'sex'])

dict_values(['韦小宝', 20, '男'])

（4）循环打印键或者值 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

for i in dic.keys():

print(i)

结果为：

name

age

sex

（5）同时输出键值 

dic={

'name':'韦小宝',

'age':20,

'sex':'男',

}

for k,v in dic.items():

print(k,v)

结果为：

name 韦小宝

age 20

sex 男

4 字典的嵌套

（1）给name_list增加一个值"姜维" 

dic={

'name_list]':['诸葛亮','庞统','司马懿',],

2:{

'leader':'刘备',

'age':'',

}

}

dic['name_list]'].append('姜维')

print(dic)

结果为：{'name_list]': ['诸葛亮', '庞统', '司马懿', '姜维'], 2: {'leader': '刘备', 'age': ''}}

（2）给字典里边的2（字典）增加一个键值对"wife:孙尚香" 

dic={

'name_list]':['诸葛亮','庞统','司马懿',],

2:{

'leader':'刘备',

'age':'',

}

}

dic[2]['wife']='孙尚香'

print(dic)

结果为：{'name_list]': ['诸葛亮', '庞统', '司马懿'], 2: {'leader': '刘备', 'age': '', 'wife': '孙尚香'}}

5 删除字典中键值包含"k"的键值对 
dic = {

'k1': 'v1',

'k2': 'v2', 'k3':'v3',

'name':'alex'

}

l1=[]

for i in dic:

if 'k' in i:

l1.append(i)

print(l1)

for i in l1:

del dic[i]

print(dic)

结果为：

['k1', 'k2', 'k3']

{'name': 'alex'}

6 Python 字典 fromkeys() 函数

用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。 

dic={}

dic=dic.fromkeys('abc',666)

print(dic)

dic=dic.fromkeys('abc',[])

print(dic)

结果为：

{'a': 666, 'b': 666, 'c': 666}

{'a': [], 'b': [], 'c': []}
seq = ('name', 'age', 'sex')

dict = dict.fromkeys(seq)

print ("新的字典为 : %s" % str(dict))

dict = dict.fromkeys(seq, 10)

print ("新的字典为 : %s" % str(dict))

结果为：

新的字典为 : {'name': None, 'age': None, 'sex': None}

新的字典为 : {'name': 10, 'age': 10, 'sex': 10}

相关阅读

目录[+]