Python保姆级教程 数据类型—新手小白入门必看系列

推荐使用压缩软件和杀毒软件


7 - zip

使用火绒

一、基本数据类型与变量(上)

2.1 注释

优点:

  1. 代码说明

没注释的代码

有注释的代码

  1. 不让解释器执行注释的那句话

2.2 单行注释

单行注释快捷键:ctrl + ?

2.3多行注释

"""""" (三个双引号)

2.4 字面量变量

字面量是已经被定义好的量
在程序中可以直接使用的字面量:1,2,3,4,5,6

185730213551

什么是变量:可以改变的量

计算机用来存贮数据的盒子,想用这个数据,就直接那盒子就好了

变量名 = 值

a = 10
print(a)

10

不要把赋值语句的等号等同于数学的等号:

x = 10
x = x +2
a = 'abc'
b = a
a = 'edg'
print(b)

abc

说明:

1.变量就是可以变化的量,可以随时进行修改
2.程序是使用来处理数据的,而变量就是用来存贮数据的
3.变量就是一个存贮数据时,当前数据所在的内存地址的名字

多个变量赋值

a, b, c = 1, 2, 'd'
print(a)
print(b)
print(c)

1
2
d

a = b = c = 1
print(a)
print(b)
print(c)

1
1
1

2.5 标识符和关键字

规则如下:

  • 由数字,字母,下划线组成
  • 不能以数字开头
  • 不能使用内置的关键字
  • 严格区分大小写

2.6命名规范

  • 标识符命名要做到见名知意

name ,age ,

遵守命名规范

  • 驼峰命名法:大驼峰和小驼峰命名法
  • 大驼峰:每一个单词的首字母都采用大写字母

First Name, Last Name

  • 小驼峰:第一个单词以小字母开始;第二个单词的首写字母大写

myName , youName

2.7关键字

具有特殊功能的的标识符,就是关键字

关键字不能声明为变量名

#打印python的所有关键字
import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

2.8 基本数据类型初始

数值类型

2.8.1 整数类型 int

1 ,2 ,3, 100, 200, -300, 0

n = 78
print(n)

78

a = 1000_0000_0000_0000
b = 1000000000000000
print(a)
print(b)

1000000000000000
1000000000000000

2.8.2 浮点类型 float

1.23×10^9

12.3×10^8

1.23 , 3.14, -9.1

1.23e9, 12.3e8, 0.000012==》1.2e-5

rount

两种方式表示浮点数

  • 十进制形式 ,1.2 , 1.23 , 12.3
  • 指数形式 (科学计数法)
aen 或者 aEn
a为尾数部分,n是指数部分,E或e是固定的字符,用于分割尾数部分和指数部分
2.1e5 = 2.1×10^5 其中2.1是尾数,5是指数
3.7E-2 = 3.7×10^-2 其中3.7是尾数,-2是指数
0.5E7 = 0.5×10^7 其中0.5是尾数, 7是指数
14E3 = 14×10^3  其中14是尾数,3是指数

print(14E3)

float1 = 0.0000000000000000000847
print(float1)

14000.0
8.47e-20

2.8.3 布尔值 bool

只有True 和False 两种值,注意大小写

True 表示真(表示条件满足或者成立) ==》1

False 表示假(表示条件不满足或者不成立) == 》0

print(3>2)
print(2>3)

True
False

2.8.4 字符串 str

不属于数值类型,它是序列类型

以单引号,双引号,三引号括起来的任意文本,abc , xyz

基本使用

name = 'python'
age = 18
jiaxiang = '湖北'
print(name+jiaxiang)  # 相加就是简单的字符串拼接
print(name*5) # 相乘就相当于将字符串和自己相加了5次

python湖北
pythonpythonpythonpythonpython

两种取值顺序:

  • 从左到右索引默认0开始,最大范围是字符串长度少1
  • 从右往左索引默认-1开始,最大范围是字符串的开头
str3 = 'abcdefg'
print(str3[2])
print(str3[6])
print(str3[-1])

c
g
g

子字符串[初始位置:结束位置],包头不包尾 ,左闭右开
str3 = 'abcdefg'
print(str3[1:6])
print(str3[:6])
print(str3[3:])

bcdef
abcdef
defg

2.9 查看数据类型

  • 变量没有类型,数据才有类型

type(变量的名字)==》查看数据类型

a = 'ab'
b = 123
c = 1.23

print(type(a))
print(type(b))
print(type(c))

<class 'str'>
<class 'int'>
<class 'float'>

2.9.1 转义字符 \

\n ==》 换行

\t ==》 制表符, 一个tab键,也就是四个空格

\ \ ==》\

转义符 必须写在引号内,转义就是把他变蠢了

print('床前明月光,\n疑是地上霜')
print('床前明月光,\t疑是地上霜')

床前明月光,
疑是地上霜
床前明月光,	疑是地上霜

print('\\\n\\')

\
\
height = 175.0
print('您的身高是:'+height) # 报错
print('您的身高是:'+str(height))

i = int('123')
print(i)
ii = ('123个')
print(ii)


您的身高是:175.0
123
123个

看到这里给大家留一个彩蛋,初学作业

1.用变量给自己建立个角色信息,要输出出来
    姓名
    年龄
    身高
    家乡
    兴趣
    是否有编程基础
2.有一个字符串变量  s = '人生苦短,我学python'
    通过下标索引,分别输出 苦,学 o 这几个字符


二、数据类型(下)

1.1 列表生成式

list [1,2,3,4,5,6,7,8,9]

list1 = [1,2,3,4,5,6,7,8,9]
print(list1)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

print(list(range(1,10)))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

1.1.1 普通的列表生成式

# 普通写法
li = []
for i in range(1,10):
    li.append(i)
print(li)

# 列表生成式写法
print([i for i in range(1,10)])
[1*1,2*2,3*3,4*4,...,9*9]
# 普通写法
li = []
for i in range(1,10):
    li.append(i*i)
print(li)

# 列表生成式
print([i*i for i in range(1,10)])
[1*2,2*3,3*4,...,9*10]
# 普通写法
li = []
for i in range(1,10):
    li.append(i*(i+1))
print(li)

# 列表生成式
print([i*(i+1) for i in range(1,10)])

[2, 6, 12, 20, 30, 42, 56, 72, 90]
[2, 6, 12, 20, 30, 42, 56, 72, 90]
# 求偶数 ,普通写法
li = []
for i in range(1,11):
    if i % 2 == 0:
        li.append(i)
print(li)

# 带if的列表生成式
print([i for i in range(1,11) if i % 2 == 0])

[2, 4, 6, 8, 10]
[2, 4, 6, 8, 10]

使用两层循环,生成一切组合可能(ABC和123)

# 普通写法
li = []
for i in 'ABC':
    for j in '123':
        li.append(i+j)
print(li)

# 双层循环写法
print([i+j for i in 'ABC' for j in  '123'])

['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

1.2 元组 tuple

元组通常使用一对小括号将所有元素包围起来,但是小括号不是必须的

tuple1 = 'python教程', 'Java'
print(tuple1)
print(type(tuple1))

1.2.1 查

count()
tuple2 = (123, 'Google', 'JD', 'Taobao', 123)
print(tuple2.count(123))  # 2
print(tuple2.count('JD'))

2
1
index()
检索某个元素的下标值
t = (123, 'Google', 'JD', 'Taobao', 123)
print(t.index(123))
print(t.index(123,1))

0
4

1.2.2 功能

1相加,两个元组相加生成一个新的元组
data = ('张三', '李四') + ('王五', '赵六')
print(data)
('张三', '李四', '王五', '赵六')

2.相乘
data = ('张三', '李四')*2
print(data)
('张三', '李四', '张三', '李四')

3.获取长度
data = ('张三', '李四')
print(len(data))
2
4.索引
data = ('张三', '李四', '王五', '赵六')
print(data[0])
print(data[1])
print(data[2])
print(data[3])

张三
李四
王五
赵六

5.切片
data = ('张三', '李四', '王五', '赵六')
print(data[0:3])
('张三', '李四', '王五')

6.步长,隔多少取值
data = ('张三', '李四', '王五', '赵六')
print(data[1:4:2]) # 1是开始位置,4是结束位置,2是步长
('李四', '赵六')

7.for循环
data = ('张三', '李四', '王五', '赵六')
for i in data:
    if i == '李四':
        continue  # 结束本次循环 ,继续执行下一次循环
    print(i)
    
张三
王五
赵六

元组的本身是不可变的,如果元组中包含其他可变元素,这些可变元素就可以改变

1.3字符串格式化输出

你好某某某 我叫某某某 再见某某某
name = 'python'
age = 18
print('大家好, 我叫'+name+', 我今年'+str(age)+'岁')

1.3.1% 方法(占位符)

%s = 字符串 ==》只能放在字符串里面
%d = 整数 ==》 只能放整数
%f = 小数 ==》默认保留六位小数
	%.1f ==> 保留一位小数
    %.2f ==> 保留两位小数
语法:('xx%dxxx%s'%(变量1,变量2))# 或者带入变量数据
name = 'python'
age = 18
height = 175.0
print('你好,我叫%s, 今年%d岁了, 身高%f'%(name,age,height))
print('你好,我叫%s, 今年%d岁了, 身高%.1f'%(name,age,height))
print('你好,我叫%s, 今年%d岁了, 身高%.2f'%(name,age,height))

你好,我叫python, 今年18岁了, 身高175.000000
你好,我叫python, 今年18岁了, 身高175.0
你好,我叫python, 今年18岁了, 身高175.00

s = '我叫%s, 今年%d岁了, 身高%f'
print(s%('python', 15, 175.0))

我叫python, 今年15岁了, 身高175.000000

1.3.2 format()

语法:
name = 'python'
age = 18
height = 175.0
print('你好, 我叫{},今年{}岁了,身高{}'.format(name,age,height))

传入的数据类型是不限的,字符串,元组,列表都行
数据跟{}顺序从左到右一一对应
直接传数据
传入多个数据:
'{}{}{}'.format(数据1,数据2,数据3)
print('你好,我叫{},今年{}岁了,身高{}'.format('python',18,175.0))
自定义数据:
'{下标}{下标}'.format(数据1,数据2)
print('你好,我叫{0},今年{2}岁了,身高{1}'.format('python',175.0,18))

1.3.3 f-format

语法:在字符串里面加上一个f/F,把要输出的变量用大括号{}包裹
name = 'python'
age = 18
height = 175.0
print(f'大家好,我叫{name},我今年{age}岁了,身高是{height}')
print(f'大家好,我叫{name[0]},我今年{age+1}岁了,身高是{height-10}')

大家好,我叫python,我今年18岁了,身高是175.0
大家好,我叫p,我今年19岁了,身高是165.0




三 数据类型进阶(上)

2.1散列类型

1.数据类型:int , float , bool ==>存储一个数值

2.序列类型: str, list , tuple ==》存储多个数据

3.散列类型

无序 内部元素不重复 没有下标

2.1.1字典 dict

用来保存一些有典型的对应关系的数据类型,特点是使用键值对的方式来存储数据

key === > 键 value===> 值

键值对的语法:key:value

表现形式:

{},不过大括号里面如果存储的是键值对,那么就是字典

通过键查找值

字典名[键]

字典的key不可以是重复的,如果重复则取最后一个重复键的值

call = {'python':'11234', 'look':'11235', '阿尔法':'11236'}
user = {'姓名':'python', '年龄':18, '工作':'python讲师'}

print(call['python'])
print(user['工作'])

dict1 = {'a':1, 'b':2, 'a':3, 'a':4}
print(dict1)

11234
python讲师
{'a': 4, 'b': 2}

可变性

dict1 = {'a':1, 'b':2, 'a':3, 'a':4}
dict1['b'] = 100
print(dict1)
{'a': 4, 'b': 100}

当我们想要表示一组固定信息的时候,用字典就可以更加的直观

字典包含多个键值对,key是字典的关键数据,程序对字典的操作都是基于key的
- 通过key访问value
- 通过key添加key-value对
- 通过key删除key-value对
- 通过key修改key-value对
- 通过key判断指定key-value对是否存在
通过key访问value
scores = {'语文':89}
print(scores['语文'])

如果腰围字典添加key-value对,就只需要为不存的key赋值就可以了
scores['数学'] = 93
scores[92] = 8.4
print(scores)

如果要删除字典中的键值对,就可以使用del语句
del scores['语文']
del scores['数学']
print(scores)

对存在的键值对赋值,新的值会覆盖原来的值
cars = {'bmw':88, 'benchi':83, 'tesila':95}
cars['benchi'] = 4.3
cars['tesila'] = 3.8
print(cars)

判断字典是否包含指定的key,使用in或者not in
in  not in # in 包含   not in 不包含
cars = {'bmw':88, 'benchi':83, 'tesila':95}
print('tesila' in cars)
print('baoshijie' in cars)
print('BYD' not in cars)

字典的key可以是任意的不可变类型

字典允许直接对不存在的key赋值,这样就可以增加一个键值对

常用方法

字典方法
print(dir(dict))

['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 
 
 
 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

2.1.1.1 clear()

用于清空点中所有的键值对

cars = {'bmw':88, 'benchi':83, 'tesila':95}
print(cars)
cars.clear()
print(cars)

{'bmw': 88, 'benchi': 83, 'tesila': 95}
{}

2.1.1.2 get()

根据key获取value的

cars = {'bmw':88, 'benchi':83, 'tesila':95}
print(cars.get('bmw'))
print(cars.get('baoshijie'))
print(cars['baoshijie'])

88
None
    print(cars['baoshijie']) # 报错
KeyError: 'baoshijie'

翻车的地方 (元组)

data = (99,88,77,['左手',18],33,22,11)

data[3] [0] = 'look'

print(data)

元素不可变 但是元素内部有可变的类型 就可以改变 但只限于元组内部 可变元素

彩蛋

# 1.将列表数据[1,2,3,2,1,4,4,4,2,5,6,7,7,9,8,10,10]去重

# 2.有字典 dic = {"k1":"v1","k2":"v2","k3":"v3"},实现以下功能:
(1)、遍历字典 dic 中所有的key
(2)、遍历字典 dic 中所有的value
(3)、循环遍历字典 dic中所有的key和value
(4)、添加一个键值对"k4","v4",输出添加后的字典 dic
(5)、删除字典 dic 中的键值对"k1" "v1",并输出删除后的字典 dic
(6) 获取字典 dic中“k2"对应的值
# 3.students =[
{'name':'go','age':18,'score':98,'tel':'18888888888', gender':'female'},
{'name''Java'age :20 'score':95."tel’: 18888888889' 'aender'.'unkown'},
{'name':'python' 'age' 18 'score':88.'tel':'18888888810' 'gender':'male'},
{'name':'php','age':16,'score':58,'tel':'18888888811', 'gender':'unkown'},
{'name':'c' 'age':19.'score':78.'tel':'18888888812' 'gender': male'},
{'name':'c++' 'age':17.'score':92,'tel':'18888888813','gender':'male'},
]

#(1)统计及格学生的个数
#(2)打印不及格学生的名字和对应的成绩
# #(3)删除性别不明的所有的学生



四、数据类型进阶(中)

1.1 update()

可以使用一个字典所包含的键值对来更新已经有的字典,如果被更新的字典包含对应的键值对,那么原来的值会被覆盖,如果不包含,就会被添加进去

cars = {'bmw':88, 'benchi':83,'tesila':95}
cars.update({'bmw':4.5,'baoshijie':9.3})
print(cars)
{'bmw': 4.5, 'benchi': 83, 'tesila': 95, 'baoshijie': 9.3}

1.2 items(), keys(), values()

dict_items,dict_keys,dict_values对象,python不希望用户直接操作这几个方法,但是可以通过list()函数把他们转成列表

items()==》取键值对
cars = {'bmw':88, 'benchi':83,'tesila':95}
ims = cars.items()
print(ims)
print(type(ims))
print(list(ims))
print(list(ims)[1])

dict_items([('bmw', 88), ('benchi', 83), ('tesila', 95)])
<class 'dict_items'>
[('bmw', 88), ('benchi', 83), ('tesila', 95)]
('benchi', 83)

keys()==> 取键
cars = {'bmw':88, 'benchi':83,'tesila':95}
kys = cars.keys()
print(kys)
print(type(kys))
print(list(kys))
print(list(kys)[1])

dict_keys(['bmw', 'benchi', 'tesila'])
<class 'dict_keys'>
['bmw', 'benchi', 'tesila']
benchi

cars = {'bmw':88, 'benchi':83,'tesila':95}
vals = cars.values()
print(vals)
print(type(vals))
print(list(vals))
print(list(vals)[1])

dict_values([88, 83, 95])
<class 'dict_values'>
[88, 83, 95]
83

程序调用字典的三个方法后,都需要调用给他们转成列表,这样就可以吧这三个方法的返回值转成列表

1.3 pop()

用于获取指定的key对应的value值,并且删除这个键值对

cars = {'bmw':88, 'benchi':83,'tesila':95}
print(cars.pop('tesila'))
print(cars)

95
{'bmw': 88, 'benchi': 83}

1.4 setdefault()

能返回指定的key对应的value值,如果键值对不存在,就会先为这个键设置默认的值,再返回这个键对应的值

cars = {'bmw':88, 'benchi':83,'tesila':95}
print(cars.setdefault('baoshijie',92))#两个参数,第二个是设置默认值,如果不存在就会新增键值对
print(cars)

92
{'bmw': 88, 'benchi': 83, 'tesila': 95, 'baoshijie': 92}

2.1 字典

2.1.1公共功能

长度

info = {'age':12, 'shengming':True, 'name':'fe'}
data = len(info)
print(data)

3

索引(键)

info = {'age':12, 'shengming':True, 'name':'fe'}
print(info['name']) # fe  字典 通过键 查找值
print(info['age'])  #12
print(info['xxx'])  # 报错  如果键不存在会报错

fe
12
报错

value = info.get('xxx') # 使用get方法获取值如果不存在就打印None
print(value)
None

for循环

info = {'age':12, 'shengming':True, 'name':'fe'}
#直接遍历这个字典,可以获取所有的键
for item in info:
    print(item)  #所有键
    
age
shengming
name
#使用keys方法
for item in info.keys():
    print(item)  # 所有键
    
#使用values方法
for item in info.values():
    print(item)  # 所有值
    
#使用items方法
for key,value in info.items():
    print(key,value)  #  获取所有的键值

2.2 集合

元素都是唯一的,互不相同的

{name1, name2, .....name n}
语法:
集合名 = {数据1,数据2,数据3,。。。。数据n}#如果有重复的数据,是不会被添加到内存空间里面

无法存储列表,字典,集合这些数据类型,否则会报错

#报错
print({{'a':1}})
print({[1,2,3]})
print({{1,2,3}})

要注意的是:集合中的数据必须保证是唯一的,集合对于美中数据元素,只会保留一份,也就是去重

s = {1,2,1,(1,2,3),'c','c'}
print(s)

{1, 2, (1, 2, 3), 'c'}

python中set是没有顺序的,每次输出时顺序都有可能不同

set1 = {1,2,3,4,5,5,1,2,3,4,5,6,7,9,1}
print(set1)
# print(set1[1])
print(type(set1))

{1, 2, 3, 4, 5, 6, 7, 9}
<class 'set'>

注意 :创建空集合的时候必须要使用set()而不是{},因为{}默认是空字典

li1 = [] # 空列表
tu1 = () # 空元组
str1 = '' # 空字符串
dict1 = {} # 空字典
set1 = set() #空集合
# 去重并转为列表输出
li = [1,2,3,4,5,6,7,89,41,1,1,1]
# li1 = set(li)
# li2 = list(li1)
# print(li1)
# print(li2)

print(list(set(li)))
[1, 2, 3, 4, 5, 6, 7, 41, 89]

2.2.1 集合的数学运算

运算符操作 python运算符 含义
交集 & 取两集合公共的元素
并集 | 取两集合全部的元素
差集 - 取一个集合中另一集合没有的元素
成员运算 in 和 not in 判断某个元素是否在或者不在集合中
集合1 & 集合2——》判断交集
集合2 | 集合1——》判断并集
集合1 - 集合2——》判断差集

交集:两个集合里面共同有的数据
并集:两个集合里面的全部数据(不包括重复数据,集合本身也不能重复)
差集:集合1 - 集合2  减去共有的,剩下的就是差集


set1 = {1,2,3}
set2 = {3,4,5}
print(set1 & set2)
print(set1 | set2)
print(set1 - set2)# 差集{1, 2} 取一个集合中另一个集合没有的元素,将set1中属于set2的元素删除
print(set2 - set1)# 4,5
print(3 in set2)

{3}
{1, 2, 3, 4, 5}
{1, 2}
{4, 5}
True

集合的作用:

  1. 存储非重复数据
  2. 用于将序列类型去重,逻辑判断(交集,并集,差集)

2.2.2 增

add() 参数为要添加的对象,通过多次添加数据可以发现添加后的元素位置不确定

语法: 集合名.add(元素)
s = {'Java'}
s.add('python')
print(s)
s.add('go')
print(s)
s.add('c')
print(s)
s.add('c++')
print(s)

{'Java', 'python'}
{'go', 'Java', 'python'}
{'go', 'Java', 'python', 'c'}
{'c', 'c++', 'go', 'python', 'Java'}

update() 参数为序列类型,会将每一个元素迭代添加到序列中(随机添加)

s = {'fe'}
s.update('123')
print(s)
s.update([4,5,6])
print(s)

{'3', '2', 'fe', '1'}
{'2', 4, 5, 6, '3', '1', 'fe'}

2.2.3 删

pop()随机删除一个元素

实际上在进行代码实验的时候并不是随机的
仅仅是在集合元素是字符串类型时,并且在cmd运行的时候才会随机删除,pycharm中默认保持删除第一个元素
s = {'fe'}
s.update('123')
print(s)
s.update([4,5,6])
print(s)
s.pop()
print(s)
s.pop()
print(s)

{'2', '1', 'fe', '3'}
{'1', 4, 'fe', 5, 6, '2', '3'}
{4, 'fe', 5, 6, '2', '3'}
{'fe', 5, 6, '2', '3'}

remove(参数)有参数,参数就是要删除的元素,如果元素不存在就报错

集合名.remove(元素)
s = {'fe'}
s.update('123')
print(s)
s.update([4,5,6])
print(s)
s.remove('1')
print(s)
s.remove('2')
print(s)
s.remove('8')
print(s)

{'1', 'fe', '2', '3'}
{4, 5, 6, '3', '1', '2', 'fe'}
{4, 5, 6, '3', '2', 'fe'}
{4, 5, 6, '3', 'fe'}
报错

discard()跟remove相似,但是元素不存在也不会报错

s = {'fe'}
s.update('123')
print(s)
s.update([4,5,6])
print(s)
s.discard('aaa')
print(s)

{'3', '1', 'fe', '2'}
{4, 5, 6, '3', 'fe', '1', '2'}
{4, 5, 6, '3', 'fe', '1', '2'}

clear() 清空集合中的元素

s = {'fe'}
s.update('123')
print(s)
s.update([4,5,6])
print(s)
s.clear()
print(s)

{'1', '3', '2', 'fe'}
{'2', 4, 5, 6, 'fe', '3', '1'}
set()

del () 集合名(),删除集合

# 整个吧盒子(变量)删除了,所以会报错,先删除了盒子,再去打印这个s就会报错显示盒子s不存在
s = {'fe'}
s.update('123')
print(s)
s.update([4,5,6])
print(s)
del s
print(s)

2.2.4 改

由于set中的数据没有索引,也没有办法去定位一个元素,所以没办法直接修改
先删除在添加
s = {'A', 'B', 'C', 'D'}
# 把A改为E
s.remove('A')
s.add('E')
print(s)

{'B', 'E', 'C', 'D'}

2.2.5查

set是一个可迭代对象,可以通过for循环进行遍历查询
s = {'A', 'B', 'C', 'D'}
for i in s:
    print(i)
    
A
C
D
B
复习巩固 练习题
 在终端中获取颜色(RGBA),打印描述信息,否则提示颜色不存在
    "R" -->"红色"
    "G" -->"绿色"
    "B" -->"蓝色"
    "A" -->"透明度"
# 1.将列表数据[1,2,3,2,1,4,4,4,2,5,6,7,7,9,8,10,10]去重
li1 = [1,2,3,2,1,4,4,4,2,5,6,7,7,9,8,10,10]
li2 = []
for i in li1:
    if i not in li2:
        li2.append(i)
print(li2)
#或者
print(list(set(li1)))

# 2.有字典 dic = {"k1": "v1", "k2": "v2", "k3": "v3"},实现以下功能:
# (1)、遍历字典 dic 中所有的key
dic = {"k1": "v1", "k2": "v2", "k3": "v3"}
for key in dic.keys():
    print(key)
# (2)、遍历字典 dic 中所有的value
for value in dic.values():
    print(value)
 # (3)、循环遍历字典 dic 中所有的key和value
for key,value in dic.items():
    print(key,value)
# (4)、添加一个键值对"k4","v4",输出添加后的字典 dic
dic['k4'] = 'v4'
print(dic)
# (5)、删除字典 dic 中的键值对"k1","v1",并输出删除后的字典 dic
dic.pop('k1')
print(dic)
# (6)、获取字典dic中“k2”对应的值
print(dic.get('k2'))

students = [
    {'name': 'Java', 'age': 18, 'score': 98, 'tel': '18888888888', 'gender': 'female'},
    {'name': 'c', 'age': 20, 'score': 95, 'tel': '18888888889', 'gender': 'unkown'},
    {'name': 'python', 'age': 18, 'score': 88, 'tel': '18888888810', 'gender': 'male'},
    {'name': 'c++', 'age': 16, 'score': 58, 'tel': '18888888811', 'gender': 'unkown'},
    {'name': 'php', 'age': 19, 'score': 78, 'tel': '18888888812', 'gender': 'male'},
    {'name': 'go', 'age': 17, 'score': 92, 'tel': '18888888813', 'gender': 'male'},
]
# (1)统计及格学生的个数
count = 0 #初始化一个值
for d in students:
    if d['score'] >= 60:
        count += 1
print(count)

# (2)打印不及格学生的名字和对应的成绩
for d in students:  #d是字典
    if d['score'] < 60:
        print(d['name'],d['score'])
# (3)删除性别不明的所有的学生
for d in students:
    if d['gender'] == 'unkown':
        #pop根据下标  remove根据值删除  clear 清空  del 列表名[下标]
        students.remove(d)  # 删除性别不明
print(students)





复习巩固答案

1.编写一个程序,检查任意一个年份是否是闰年
- 如果一个年份可以被4整除不能被100整除,或者可以被400整除,这个年份就是闰年
year = int(input('请输入一个年份:'))
if year % 4 == 0 and year % 100 != 0 or year %400 == 0:  # != 不相等
    print(year,'是闰年')
else:
    print(year,'是平年')

2.从键盘输入小明的期末成绩:
	当成绩为100时,'奖励一辆BMW'
    当成绩为(80-99)时,'奖励一台iphone'
    当成绩为(60-79)时,'奖励一本参考书'
    其他时,奖励棍子一根

3.计算1+2+3+...+100(使用while循环)

num = 1
sum = 0  # 初始化一个累计的变量
while num < 101:
    sum += num
    num += 1  # num1 =num + 1
print('num=',sum)

4.打印99乘法表:
1*1=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
1*4=4	2*4=8	3*4=12	4*4=16
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end='\t')
    print()



五 数据类型进阶(下)

python的数据类型可以分为三类:数值类型,序列类型,散列类型

数值类型:int , float , bool

2.1 序列类型

元素1  元素2   元素3  元素4 元素。。。。 元素n
 0      1      2       3    4         n-1
-n

# 元素下面的是索引取值
s = 'CSDN博客论坛'
print(s[0],'=',s[-8])
print(s[-1],'=',s[7])

C = C
坛 = 坛

2.2 字符串 str

字符串是一个有序的字符集和,用于存贮和表示基本的文本信息

2.2.1 常用方法

操作数据最本质的行为是什么?== 》增删改查

字符串.方法名

2.2.1.1 find

find的作用:范围性查找子串,返回索引值,没有则返回-1

语法:

str.find(str,beg=0,end=len(string))
  • str==> 指定检索的字符串
  • beg==》开始的索引,默认值为0
  • end==》结束的索引,默认为字符串的长度

find常用于检测字符串中是否包含子字符串str

s = 'hello world'
print(s.find('o'))  #o 的索引值就是4
print(s.find('hello')) # 找到hello则返回首个字符的索引
print(s.find('worldd')) # 找不到返回-1

s = ('python,helloworld,java,php')
print(s.find('h'))  # 返回的是首个h的下标
print(s.find('h',4))  # 从下标为4的地方开始找
print(s.rfind('h'))  # 从后往前找

2.2.1.2 index()

检测字符串中是否包含子字符串str,如果指定beg和end范围,则检查是否包含在指定范围内,和find差不多,只不过如果子str不在str中会报错

s = ('python,helloworld,java,php')
print(s.index('world'))  # 12 索引值
print(s.index('worldd'))  # 报错

2.2.1.3 count()

返回找到的子串个数

s = ('python,helloworld,java,php')
print(s.count('h'))  # 3 h的个数

2.2.1.4 strip()

去除字符串两边的空格,换行符,制表符,得到的是一个新的字符串

code = input('请输入4位的验证码:')
data = code.strip()
if data == 'ABCD':
    print('验证码正确')
else:
    print('验证码错误')

2.2.1.5 startswith(), endswith()

  • 判断字符串是否已xx开头,得到一个布尔值
dizhi = input('请输入住址:')
if dizhi.startswith('北京市'):
    print('北京人口')
else:
    print('非北京人口')
  • 判断字符串是否已xx结尾,得到一个布尔值
dizhi = input('请输入住址:')
if dizhi.endswith('村'):
    print('农业户口')
else:
    print('非农业户口')
s = '北京市朝阳区'
print(s.startswith('北京市'))

2.2.1.6 isdigit()

  • 判断字符串是否是数字组成,返回的结果是布尔值
v1 = input('请输入第一个值:')
v2 = input('请输入第二个值:')
if v1.isdigit() and v2.isdigit():
    data = int(v1)+int(v2)
    print(data)
else:
    print('请输入正确的数字')

2.2.1.7lower() 和 upper()

字符串变大写/小写,得到一个新的字符串

lower()==》转小写

upper()==》转大写

s = 'C'
print(s)
s1 = s.lower()
print(s1)
s2 = s1.upper()
print(s2)

C
c
C

2.2.1.8 split()

切分字符串,将字符串类型转成列表,默认以空格切分,也可以指定字符切分

s = 'my name is zuoshou'
print(s.split())
s1 = 'python,helloworld,java,php'
print(s1.split(','))

['my', 'name', 'is', 'zuoshou']
['python', 'helloworld', 'java', 'php']

2.2.1.9 replace()

字符串内容的替换,得到一个新的字符串

s = input('请输入评论信息:')
s1 = s.replace('草','*')
print(s1)

2.2.1.10 join()

用于将序列中的元素以指定的字符串连接生成一个新的字符串

常用于将列表转为字符串

a = ['Java', '和', 'python', '是', '好朋友']
print(''.join(a))  # 常用于转化列表为字符串时使用
print('-'.join(a))

Java和python是好朋友
Java-和-python-是-好朋友

2.2.2 字符串的公共功能

2.2.2.1正向取(从左往右),反向取(从右往左,负号)

s = 'hello python'
# 正向取值
print(s[0])  #  取值为 h
print(s[5])  #  空格,空格也算是字符串里的一个字符
# 反向取值
print(s[-4]) # 取值为 t

len的用法
len 是从1开始数  计量字符串长度
print(s[len(s)-1])  # 最后一个值
print(len(s))   # len  计算字符串的长度
print(s[-len(s)])  # len 前面加负号 是从右到左取值

2.2.2.2 切片(顾头不顾尾,步长)

s = 'hello python'
print(s[::2])

hlopto

步长:0:9:2 第三个参数2代表步长,会从下标0开始,每次累加一个2就可以
print(s[0:9:2])

hlopt

print(s[::-1]) # 从右到左依次取值 反向取值 步长为负数就是从右到左 首尾不给值就是取所有
nohtyp olleh

2.3 列表 list

可以存放多个不同类型的元素,记录多个同种属性的值

列表:存贮同一个类别的数据,方便操作

字符串,不可变类型:创建好之后内部无法修改[内置功能都是新创建一份数据]
name = 'java'
data = name.upper()
print(name)
print(data)

java
JAVA  
列表,可变类型:创建好之后内部元素可以修改[独有功能基本上都是直接操作列表内部的,不会创建一份新的数据]

list1 = ['车子', '房子']
list1.append('妹子')  # append  ’添加‘的方法
print(list1)

['车子', '房子', '妹子']

列表的创建

列表名 = []

2.3.1 增

1.append:添加一个数据,添加到列表的最后一位
   语法: 列表名.append('python')
li..append('python')
print(li)
[2, 3, 4, 5, 6, 7, 8, 9, 10, 'python']

2.insert: 添加一个数据到指定位置
    语法:列表名.insert(下标位置,内容)
   li.insert(0,'look')
print(li)
['look', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'python']

3.extend:添加一个序列类型到最后一位,并且吧序列类型拆分
    语法:列表名.extend(序列类型)
  li.extend('吸血鬼')
print(li)
li.extend(['吸血鬼'])
print(li)
['look', 2, 3, 4, 5, 6, 7, 8, 9, 10, '左手', '吸', '血', '鬼']
['look', 2, 3, 4, 5, 6, 7, 8, 9, 10, '左手', '吸', '血', '鬼', '吸血鬼']

2.3.2 删

pop:删除一个值,默认从最后一个开始删,也可以指定位置
    语法:列表名.pop()
    列表名.pop(下标)
    li.pop(-1)
print(li)
['look', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'python', '吸', '血', '鬼']

remove:删除一个指定的值,如果有多个,从第一个开始删
    语法:列表名.remove(删除对象)
    li.remove(3) # 删除对象
print(li)

['look', 2, 4, 5, 6, 7, 8, 9, 10, 'python', '吸', '血', '鬼']

clear :清空列表里面的所有数据
    语法:列表名.clear()
    li.clear()
print(li)

[]
del : 全局删除,可以删除一个变量
    语法:del 列表名[下标]
del li[3]  # 下标
print(li)

['look', 2, 4, 6, 7, 8, 9, 10, 'python', '吸', '血', '鬼']

2.3.3 改

单个修改:直接通过下标进行修改
语法:列表名[下标] = 内容
li[1] = '阿尔法'
print(li)
['look', '阿尔法', 4, 6, 7, 8, 9, 10, 'python', '吸', '血', '鬼']

多个修改:通过切片的方式进行修改
语法: 列表名[起点:终点] = 数值1, 数值2
li[1:3] = 70,20
print(li)
['look', 70, 20, 6, 7, 8, 9, 10, '左手', '吸', '血', '鬼']

2.3.4查

index:根据内容获取指定数据的下标
    语法:列表名。index(要找的内容)
    print(li)
print(li.index(8)) 
5
列表名。index(要找的内容,起点值)
print(li.index(20,5)) #报错,显示20不在列表中

count:统计数据出现的次数
    语法:列表名.count(要找的内容)
    print(li.count(10))
          1

2.3.5 其他

排序(全int的列表才可以排序)
sort:让列表的内容按照降序/升序的方式来排序
    列表名.sort()——》升序
li1 = [1,85,6,8,61,3,45321,1965]
li1.sort()
print(li1)

[1, 3, 6, 8, 61, 85, 1965, 45321]

    列表名.sort(reverse=True)——》降序
li1 = [1,85,6,8,61,3,45321,1965]
li1.sort(reverse=True)
print(li1)

[45321, 1965, 85, 61, 8, 6, 3, 1]

热门相关:流鱼无恙   上神来了   闺范   裙上之臣   万古至尊