菜鸟Python笔记-基础篇04：字符、列表、元组、字典

一、字符串介绍

python中字符串的格式

如下定义的变量a，存储的是数字类型的值

a = 100

如下定义的变量b，存储的是字符串类型的值

b = "hello world"
或
b = 'hello world'

小总结：

双引号或者单引号中的数据，就是字符串

二、字符串输出

demo

name = 'laowang'
position = '老司机'
address = '北京市'

print('--------------------------------------------------')
print("姓名：%s" % name)
print("职位：%s" % position)
print("公司地址：%s" % address)
print('--------------------------------------------------')

结果:

--------------------------------------------------
姓名： laowang
职位： 老司机
公司地址： 北京市
--------------------------------------------------

三、字符串输入

之前在学习input的时候，通过它能够完成从键盘获取数据，然后保存到指定的变量中；
注意：input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存。

demo:

userName = input('请输入用户名:')
print("用户名为：%s" % userName)

password = input('请输入密码:')
print("密码为：%s" % password)

结果：（根据输入的不同结果也不同）

请输入用户名:hello
用户名为： hello
请输入密码:haohaoxuexitiantianxiangshang
密码为:haohaoxuexitiantianxiangshang

四、下标和切片

1. 下标索引

所谓“下标”，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间。

字符串中"下标"的使用

列表与元组支持下标索引好理解，字符串实际上就是字符的数组，所以也支持下标索引。
如果有字符串:name = 'abcdef'，在内存中的实际存储如下:
[站外图片上传中...(image-182e-1534433546212)]
如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）

name = 'abcdef'

print(name[0])
print(name[1])
print(name[2])

运行结果:

a
b
c

2. 切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法：[起始:结束:步长]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

我们以字符串为例。
如果取出一部分，则可以在中括号[]中，使用:
demo1

name = 'abcdef'

print(name[0:3]) # 取 下标0~2 的字符

运行结果:

abc

demo2

name = 'abcdef'

print(name[0:5]) # 取 下标为0~4 的字符

运行结果

abcde

demo3

name = 'abcdef'

print(name[3:5]) # 取 下标为3、4 的字符

运行结果：

de

demo4

name = 'abcdef'

print(name[2:]) # 取 下标为2开始到最后的字符

运行结果：

cdef

demo5

name = 'abcdef'

print(name[1:-1]) # 取 下标为1开始 到 最后第2个之间的字符

运行结果：

bcde

给定一个字符串aStr, 请反转字符串

s = 'Hello World!'
# python 字符串快速逆置
print(s[::-1])  # 从后向前，按步长为1进行取值

五、列表介绍

列表的格式

变量A的类型为列表

namesList = ['xiaoWang','xiaoZhang','xiaoHua']

比C语言的数组强大的地方在于列表中的元素可以是不同类型的

testList = [1, 'a']

打印列表

demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])

结果：

xiaoWang
xiaoZhang
xiaoHua

六、列表的循环遍历

1. 使用for循环

为了更有效率的输出列表的每个数据，可以使用循环来完成
demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
print(name)

结果：

xiaoWang
xiaoZhang
xiaoHua

2. 使用while循环

为了更有效率的输出列表的每个数据，可以使用循环来完成
demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']

length = len(namesList)

i = 0

while i


结果:
xiaoWang
xiaoZhang
xiaoHua

七、列表的相关操作

列表中存放的数据是可以进行修改的，比如"增"、"删"、"改"、"查"

添加元素("增"append, extend, insert)
append
通过append可以向列表添加元素
 demo:
#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']

print("-----添加之前，列表A的数据-----")
for tempName in A:
    print(tempName)

#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
A.append(temp)

print("-----添加之后，列表A的数据-----")
for tempName in A:
    print(tempName)

结果:









结果


extend
通过extend可以将另一个集合中的元素逐一添加到列表中
>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]

insert
insert(index, object) 在指定位置index前插入元素object
>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]

修改元素("改")
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改
 demo:
#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']

print("-----修改之前，列表A的数据-----")
for tempName in A:
    print(tempName)

#修改元素
A[1] = 'xiaoLu'

print("-----修改之后，列表A的数据-----")
for tempName in A:
    print(tempName)

结果：
-----修改之前，列表A的数据-----
xiaoWang
xiaoZhang
xiaoHua
-----修改之后，列表A的数据-----
xiaoWang
xiaoLu
xiaoHua

查找元素("查"in, not in, index, count)
所谓的查找，就是看看指定的元素是否存在
in, not in
python中查找的常用方法为：

in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false

demo
#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']

#获取用户要查找的名字
findName = input('请输入要查找的姓名:')

#查找是否存在
if findName in nameList:
    print('在字典中找到了相同的名字')
else:
    print('没有找到')

结果1：(找到)
 [站外图片上传中...(image-bac139-1534433546212)]
 结果2：(没有找到)
 [站外图片上传中...(image-4992f9-1534433546212)]
 说明：

in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在

index,count
index和count与字符串中的用法相同
>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "", line 1, in 
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

删除元素("删"del, pop, remove)
类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删除掉；在开发中经常会用到删除这种功能。
列表元素的常用删除方法有：

del：根据下标进行删除
pop：删除最后一个元素
remove：根据元素的值进行删除

demo:(del)
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

print('------删除之前------')
for tempName in movieName:
    print(tempName)

del movieName[2]

print('------删除之后------')
for tempName in movieName:
    print(tempName)

结果:
------删除之前------
加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人
速度与激情
------删除之后------
加勒比海盗
骇客帝国
指环王
霍比特人
速度与激情

demo:(pop)
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

print('------删除之前------')
for tempName in movieName:
    print(tempName)

movieName.pop()

print('------删除之后------')
for tempName in movieName:
    print(tempName)

结果：
------删除之前------
加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人
速度与激情
------删除之后------
加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人

demo:(remove)
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

print('------删除之前------')
for tempName in movieName:
    print(tempName)

movieName.remove('指环王')

print('------删除之后------')
for tempName in movieName:
    print(tempName)

结果：
------删除之前------
加勒比海盗
骇客帝国
第一滴血
指环王
霍比特人
速度与激情
------删除之后------
加勒比海盗
骇客帝国
第一滴血
霍比特人
速度与激情

排序(sort, reverse)
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
 reverse方法是将list逆置。
>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

八、列表的嵌套
1. 列表嵌套

类似while循环的嵌套，列表也是支持嵌套的
 一个列表中的元素又是一个列表，那么这就是列表的嵌套

schoolNames = [['北京大学','清华大学'],
                ['南开大学','天津大学','天津师范大学'],
                ['山东大学','中国海洋大学']]

2. 应用
一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配
#encoding=utf-8

import random

# 定义一个列表用来保存3个办公室
offices = [[],[],[]]

# 定义一个列表用来存储8位老师的名字
names = ['A','B','C','D','E','F','G','H']

i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)

i = 1
for tempNames in offices:
    print('办公室%d的人数为:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)

运行结果如下:
 [站外图片上传中...(image-e7264-1534433546212)]
九、元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)

访问元组
[站外图片上传中...(image-bf61df-1534433546212)]
修改元组
[站外图片上传中...(image-cea09-1534433546212)]
 说明： python中不允许修改元组的数据，包括不能删除其中的元素。
count, index
index和count与字符串和列表中的用法相同
>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "", line 1, in 
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

十、字典介绍
说明：

字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的
字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'、'id'、'sex'）
字典的每个元素由2部分组成，键:值。例如 'name':'班长' ,'name'为键，'班长'为值

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

根据键访问值
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

print(info['name'])
print(info['address'])

结果:
班长
地球亚洲中国北京

若访问不存在的键，则会报错：
>>> info['age']
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'age'

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：
>>> age = info.get('age')
>>> age #'age'键不存在，所以age为None
>>> type(age)

>>> age = info.get('age', 18) # 若info中不存在'age'这个键，就返回默认值18
>>> age
18

十一、字典的常见操作
查看元素
除了使用key查找数据，还可以使用get来获取数据
demo:
info = {'name':'吴彦祖','age':18}

print(info['age']) # 获取年龄

# print(info['sex']) # 获取不存在的key，会发生异常

print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常

修改元素
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
demo:
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

newId = input('请输入新的学号')

info['id'] = int(newId)

print('修改之后的id为%d:'%info['id'])

结果：
 [站外图片上传中...(image-cba1b0-1534433546212)]
添加元素
demo:添加新的元素
iinfo = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

# print('id为:%d'%info['id'])#程序会终端运行，因为访问了不存在的键

newId = int(input('请输入新的学号'))

info['id'] = newId

print('添加之后的id为:%d'%info['id'])

结果:
请输入新的学号188
添加之后的id为: 188

删除元素
对字典进行删除操作，有一下几种：

del
clear()

demo:del删除指定的元素
info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

print('删除前,%s'%info['name'])

del info['name']

print('删除后,%s'%info['name'])

demo:del删除整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}

del info

demo:clear清空整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
   
info.clear()

十二、字典的遍历
通过for ... in ... 我们可以遍历字符串、列表、元组、字典等
 注意python语法的缩进
字符串遍历
>>> a_str = "hello itcast"
>>> for char in a_str:
...     print(char,end=' ')
...
h e l l o   i t c a s t

列表遍历
>>> a_list = [1, 2, 3, 4, 5]
>>> for num in a_list:
...     print(num,end=' ')
...
1 2 3 4 5

元组遍历
>>> a_turple = (1, 2, 3, 4, 5)
>>> for num in a_turple:
...     print(num,end=" ")
1 2 3 4 5

字典遍历
<1> 遍历字典的key（键）
[站外图片上传中...(image-7f1e53-1534433546212)]
<2> 遍历字典的value（值）
[站外图片上传中...(image-a8325-1534433546212)]
<3> 遍历字典的项（元素）
[站外图片上传中...(image-fd0d7b-1534433546212)]
<4> 遍历字典的key-value（键值对）
[站外图片上传中...(image-de294a-1534433546212)]
enumerate()

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>> chars = ['a', 'b', 'c', 'd']
>>> for i, chr in enumerate(chars):
...     print i, chr
...
0 a
1 b
2 c
3 d

十四、公共方法
运算符



运算符
Python 表达式
结果
描述
支持的数据类型




+
[1, 2] + [3, 4]
[1, 2, 3, 4]
合并
字符串、列表、元组


*
['Hi!'] * 4
['Hi!', 'Hi!', 'Hi!', 'Hi!']
复制
字符串、列表、元组


in
3 in (1, 2, 3)
True
元素是否存在
字符串、列表、元组、字典


not in
4 not in (1, 2, 3)
True
元素是否不存在
字符串、列表、元组、字典



python内置函数
Python包含了以下内置函数



序号
方法
描述




1
cmp(item1, item2)
比较两个值


2
len(item)
计算容器中元素个数


3
max(item)
返回容器中元素最大值


4
min(item)
返回容器中元素最小值


5
del(item)
删除变量



多维列表/元祖访问的示例
>>> tuple1 = [(2,3),(4,5)]
>>> tuple1[0]
(2, 3)
>>> tuple1[0][0]
2
>>> tuple1[0][2]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: tuple index out of range


>>> tuple1[0][1]
3
>>> tuple1[2][2]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: list index out of range


>>> tuple2 = tuple1+[(3)]
>>> tuple2
[(2, 3), (4, 5), 3]
>>> tuple2[2]
3
>>> tuple2[2][0]
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'int' object is not subscriptable

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	复制	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典

序号	方法	描述
1	cmp(item1, item2)	比较两个值
2	len(item)	计算容器中元素个数
3	max(item)	返回容器中元素最大值
4	min(item)	返回容器中元素最小值
5	del(item)	删除变量

菜鸟Python笔记-基础篇04：字符、列表、元组、字典

一、字符串介绍

python中字符串的格式

二、字符串输出

三、字符串输入

四、下标和切片

1. 下标索引

字符串中"下标"的使用

2. 切片

五、列表介绍

列表的格式

打印列表

六、列表的循环遍历

1. 使用for循环

2. 使用while循环

七、列表的相关操作

添加元素("增"append, extend, insert)

append

extend

insert

修改元素("改")

查找元素("查"in, not in, index, count)

in, not in

index,count

删除元素("删"del, pop, remove)

排序(sort, reverse)

八、列表的嵌套

1. 列表嵌套

2. 应用

九、元组

访问元组

修改元组

count, index

十、字典介绍

根据键访问值

十一、字典的常见操作

查看元素

修改元素

添加元素

删除元素

十二、字典的遍历

字符串遍历

列表遍历

元组遍历

字典遍历

<1> 遍历字典的key（键）

<2> 遍历字典的value（值）

<3> 遍历字典的项（元素）

<4> 遍历字典的key-value（键值对）

enumerate()

十四、公共方法

运算符

python内置函数

多维列表/元祖访问的示例

你可能感兴趣的:(菜鸟Python笔记-基础篇04：字符、列表、元组、字典)