Python基础

这篇博客详细介绍了Python的基础知识,包括环境安装、markdown格式、Python的运行方式、注释、数据类型、变量、常量、dir()函数、数字、复数、表达式和运算符、流程控制、Python的执行方式、字符串操作、列表、元组、字典的创建和操作,以及常用的Python库和函数。适合初学者全面了解和学习Python。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Python基础

Python

1.环境安装(exit()退出Python模式)

1.python的安装

2.pycharm(IDE)/Sublime(清量型IDE)

3.Typora(对应的格式文件:Markdown格式文件)

2.markdown格式三种方式

1.网站
2.绝对路径
3.相对路径

例:

3.Python的三种运行方式

1.Python解释器环境下运行;
2.命令窗口中运行脚本;(先按住Shift键,右键点击空白处点击Powershell然后输入python 文件名.py)
3.IDE(Sublime)运行程序

4.注释

1.单行注释
# This is 
2.多行注释
'''
  或者三双引号
'''

5.创建表格的快捷键(源码模式中用到)


姓名|班级|年龄
:-:|:-:|:-:
张三|1|18
李四|2|19

6.进入指定目录

1.当前目录前,Shift+鼠标右键,打开命令窗口(Powershell)
2.摁Win+R,输入cmd,回车,打开命令窗口,如下
C:\Users\Administrator>cd E:\python

C:\Users\Administrator>E:

E:\python>jiandan.py
你好 Python
wr 我们 219

E:\python>

7.Input函数

1.input()接手的参数默认返回字符串类型
2.print(type(a)),type:判断数据类型

8.数据类型

不同的数据需要定义不同的数据类型
1.Python中常见的数据类型
a.数字(number)
b.字符串(string)
c.布尔值(bool)
d.列表(list)
e.元组(tuple)
f.集合(set)
g.字典(dict)

9.变量

A:概念
1.程序可操作的存储区名称
2.程序运行存储区中能改变的数据
3.每个变量都有特定的类型
举例:一栋教学楼当作内存的话,教室名称就相当于变量,学生就相当于内部存储的具体的变量值
B:作用:将数据存储到内存
C:变量的定义
  变量名 = 初始值 #(初始值的实际类型决定变量的数据类型)
D:总结:python:定义变量不用给数据类型,它会自动识别并给类型
E:变量的命名:python命名规则和Java一样,唯一不同的就是关键字不一样
注意:1.通常命名时不以单下划线"_“和双下划线”——"开头,因为python中单下划线和双下划线开头的变量有特殊用途
2.见名知意
3.小驼峰
4.大驼峰
5.下划线连接
F:变量赋值:如果要把一个变量赋给另一个变量,这个变量必须先被定义
G:查询变量:
①:查询变量类型:print(type(变量名)
②:查询变量地址:print(id(变量名))
H:变量的调用
a = 1
b = 2
c = a + b
print(c)
I:两值交换(交换变量)
>>> x = 12
>>> y = 13
>>> x,y = y,x
>>> print(x,y)
13 12
J:同时赋值
>>> a = b = c=2
>>> print(a,b,c)
2 2 2

>>> a,b,c = 1,2,3
>>> print(a,b,c)
1 2 3

>>> tuple = 1,2,3   #tuple:元组
>>> print(tuple,type(tuple))
(1, 2, 3) <class 'tuple'>

10.Python关键字查看

进入python终端就是windows键+r,进入cmd命令窗口输入python
在python终端中输入:
    >>>import keyword
    >>>keyword.kwlist
结果:
    ['False', 'None', 'True', 'and', 'as', 'assert', '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']

11.优快云/CnBlogs

关于程序员的两个网页和写博客

12.常量

1.概念:常量就是不变的量,比如:pai,在程序运行过程中不可以改变的量
2.一般常量的定义所有字母大写
PI = 3.14
3.Python中已经集成了基本的数字函数和常量,我们查看一下pi的值
>>> import math
>>> math.pi
3.141592653589793

13.dir()函数

dir(函数名比如:math)
1.不带参数的:返回当前范围内定义的变量,方法,和定义的类型列表
2.带参数的:返回参数的属性和方法

14.数字

1.数字提供了标量存储和直接访问
2.是不可更改的数据类型(指变更数字会生成的对象)
a:整形
b:长整形
Python2区分整形和长整形,Python3目前已基本不区分,后续优化会逐渐合并
c:布尔型
①True(1)
②False(2)
d:浮点型(①和②包括在浮点型里)
①双精度
②十进制
3.科学计数法
用”E”或者"e"来代表10
>>> print(3.1415926E5)
314159.26
>>>

15.复数

我们知道,任何一个数的平方都是一个非负数,但现在,我们需要找到一个数的平方为负数,因此,18世纪,
数学家定义虚数(虚数基本单位i,j)

i ∗ ∗ 2 = − 1 , j ∗ ∗ 2 = − 1 i 或 者 j = − 1 i**2 = -1,j**2 = -1 i或者j = \sqrt {{\rm{ - }}1} i2=1,j2=1ij=1

基于这个特殊的数(或者称之为概念),数学从此有了一个新的分支。现在虚数已经广泛应
用于数值和科学计算应用程序中。一个实数和一个虚数的组合构成一个复数。一个复数是一对
有序浮点数(x, y)。表示为 x + yj, 其中 x 是实数部分,y 是虚数部分。
渐渐的复数在日常运算,机械,电子等行业获得了广泛的应用。由于一些研究人员不断的重
复制造用于复数运算的工具, 在很久以前的 Python1.4 版本里,复数终于成为一个真正的
Python 数据类型。
1.复数属性
例如:定义num = 1.6+5.6j则对应的常见属性为:

 例如:num = 1.6+5.6j
 1.num.real #返回复数的实部 结果为:1.6
 2.num.imag #返回复数的虚部 结果为:5.6
 3.num.conjugate() #返回复数共轭复数 结果为:(1.6-5.6j)
   #共轭复数:实部相同,虚部互为相反数

16.表达式和运算符(Python中没有++,–等)

1.表达式概念:由变量,常量和运算符组成的式子,计算机可以进行的运算有很多种,可不只加减乘除这么简单,运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算。
Python算术运算符
运算符描述实例
+加 : 两个对象相加a + b
-减 :得到负数或是一个数减去另一个数a - b
*乘 : 两个数相乘或是返回一个被重复若干次的字符串a * b
/除 : x 除以 y,返回一个实数b / a
%取模 : 返回除法的余数b % a
**幂 : 返回x的y次幂a**b
//取整除 : 返回商a//b
Python比较运算符
以下假设变量a为10,变量b为20:
运算符描述实例
==等于 - 比较对象是否相等(a == b) 返回 False。
!=不等于 - 比较两个对象是否不相等(a != b) 返回 True。
>大于 - 返回x是否大于y(a > b) 返回 False。
<小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写。(a < b) 返回 True。
>=大于等于 - 返回x是否大于等于y。(a >= b) 返回 False。
<=小于等于 - 返回x是否小于等于y。(a <= b) 返回 True。
Python赋值运算符
以下假设变量a为10,变量b为20:
运算符描述实例
=简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c
+=加法赋值运算符c += a 等效于 c = c + a
-=减法赋值运算符c -= a 等效于 c = c - a
*=乘法赋值运算符c *= a 等效于 c = c * a
/=除法赋值运算符c /= a 等效于 c = c / a
%=取模赋值运算符c %= a 等效于 c = c % a
**=幂赋值运算符c **= a 等效于 c = c ** a
//=取整除赋值运算符c //= a 等效于 c = c // a
Python位运算符(二进制转十进制的时候从右往左数从零开始数)
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下:
运算符描述
&按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。
^按位异或运算符:当两对应的二进位相异时,结果为1
~按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
<<左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。
>>右移动运算符:把">>“左边的运算数的各二进位全部右移若干位,”>>"右边的数指定移动的位数
Python逻辑运算符
运算符逻辑表达式描述
andx and y布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。
orx or y布尔"或" - 如果 x 是 True,它返回 x 的值,否则它返回 y 的计算值。
notnot x布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。
针对逻辑运算的进一步研究
1.在没有()的情况下not优先级高于and,and优先级高于or,即优先级关系为()>not>and>or,同一优先级从左往右计算
Python成员运算符
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
运算符描述实例
in如果在指定的序列中找到值返回 True,否则返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in如果在指定的序列中没有找到值返回 True,否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
Python身份运算符
身份运算符用于比较两个对象的存储单元
运算符描述实例
isis 是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False
is notis not 是判断两个标识符是不是引用自不同对象x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符:
运算符描述
**指数 (最高优先级)
~ + -按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //乘,除,取模和取整除
+ -加法减法
>> <<右移,左移运算符
&位 ‘AND’
^ |位运算符
<= < > >=比较运算符
<> == !=等于运算符
= %= /= //= -= += *= **=赋值运算符
is is not身份运算符
in not in成员运算符
not and or逻辑运算符
例子:
3>4 or 4<3 and 1==1 #False
1 < 2 and 3 < 4 or 1>2 #True
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1 #True
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8 #False
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 > 8 #True
1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #False
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #False
数据类型的强制转换
强转类型描述
int(x)将x转换成一个整数
float(x)将x转换成浮点数
int(x [,base ])将x转换为一个整数
long(x [,base ])将x转换为一
float(x )将x转换到一个浮点数
complex(real [,imag ])创建一个复数
str(x )将对象 x 转换为字符串
repr(x )将对象 x 转换为表达式字符串
eval(str )用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )将序列 s 转换为一个元组
list(s )将序列 s 转换为一个列表
chr(x )将一个整数转换为一个字符
unichr(x )将一个整数转换为Unicode字符
ord(x )将一个字符转换为它的整数值
hex(x )将一个整数转换为一个十六进制字符串
oct(x )将一个整数转换为一个八进制字符串
bin(x)将一个整数转换为一个二进制字符串
>>> for i in range(65,92):
...     print(chr(i),end='')
...
ABCDEFGHIJKLMNOPQRSTUVWXYZ[>>>

17.进制

十进制二进制八进制十六进制
00b00 00000000 00000x00 0000
10b00 00010000 00010x00 0001
20b00 00100000 00020x00 0002
30b00 00110000 00030x00 0003
40b00 01100000 00040x00 0004
50b00 01110000 00050x00 0005
60b00 10000x00 0006
70b00 10010x00 0007
80b00 10100x00 0008
90b00 10110x00 0009
100b00 11000x00 000a
110b00 11010x00 000b
120b00 11100x00 000c
130b00 11110x00 000d
140b01 00000x00 000e
150b01 00010x00 000f
160b01 0010
0110 0100 换算成十进制
第00 * 20 = 010 * 21 = 021 * 22 = 430 * 23 = 040 * 24 = 051 * 25 = 3261 * 26 = 6470 * 27 = 0
公式:第N位2(N)

18.常见的数学函数

函数名描述
abs(x)返回数字的绝对值,如abs(-10) 返回 10
fabs(x)返回数字的绝对值,如math.fabs(-10) 返回10.0
ceil(x)返回数字的上入整数,如math.ceil(4.1) ,小于等于4返回 5
floor(x)返回数字的下舍整数,如math.floor(4.9)大于等于5返回 4
round(x [,n])返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。
exp(x)返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
log(x)如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)返回以10为基数的x的对数,如math.log10(100)返回 2.0
max(x1, x2,…)返回给定参数的最大值,参数可以为序列。
min(x1, x2,…)返回给定参数的最小值,参数可以为序列。
modf(x)返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。
pow(x, y)x**y 运算后的值。
sqrt(x)返回数字x的平方根
cmp(x, y)Py2,如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1, python3中已取消使用
- cmp()函数

  python2使用,python3已取消。

  Python3中对应的使用:

  ```python
  >>>import operator

  然后:

  >>> operator.eq("a","a");

  True

  lt(a,b) 相当于 a<b     从第一个数字或字母(ASCII)比大小

        less than

    le(a,b)相当于a<=b

        less and equal

    eq(a,b)相当于a==b     字母完全一样,返回True,

        equal

    ne(a,b)相当于a!=b

        not equal

    gt(a,b)相当于a>b

        greater than

    ge(a,b)相当于 a>=b 
        greater and equal

    函数的返回值是布尔
NameError: name ... is not defined
名称错误:某某名称未被定义

19.随机函数(random)

一:模块导入
方法1
import random
方法2
from random import*
二:常用的方法

random 模块常用的功能

1.random.random():用于随机生成一个0到1的浮点数n(0<=n<=1)
>>> import random
>>> num = random.random()
>>> print(num)
0.9637473539149145
>>> print(num)
0.9637473539149145
>>> num = random.random()
>>> print(num)
0.347429211267317
2.random.uniform(a,b):用于生成指令范围的随机浮点
数,两个参数,其中之一上限,另一个是下限:
a.如果a>b,生成的随机数n:a<= n <=b;
b.如果a<b,生成的随机数n:b<= n <=a;
>>> import random
>>> random.uniform(1,10)
9.828196503352695
>>> random.uniform(10,1)
1.7689119414667456
>>>

3.random.randint(a,b):随机生成a到b范围内的整数n(a<= n <=b)
>>> random.randint(1,10)
9
4.random.randrange([start], [stop], [step]):从指定范围
内,按指基数递增的集合中 获取一个随机数。
集合为{start,start+step,start+2step,…,start+nstep}
>>> random.randrange(1, 100)
36
>>> random.randrange(1, 100)
29
>>> random.randrange(1, 100)
27
>>>
5.random.choice(sequence):从序列中随机获取一个元素
>>> import random
>>> lst = ['pyt	hon','C','C++','javascript']
>>> str1 = ('I love python')
>>> random.choice(lst)
'C'
>>> random.choice(lst)
'C'
>>> random.choice(lst)
'javascript'
>>> random.choice(str1)
't'
>>> random.choice(str1)
't'
>>> random.choice(str1)
' '
6.random.shuffle(x[, random]):用于将一个列表中的元素
打乱。即将列表内的元素随机排列。
>>> p=['A', 'B', 'C', 'D', 'E']
>>> random.shuffle(p)
>>> print(p)
['C', 'B', 'A', 'D', 'E']
>>> random.shuffle(p)
>>> print(p)
['B', 'C', 'A', 'D', 'E']
>>>
7.random.sample=(sequence,k):从指定序列中随机获取指定
长度的片段并随机排列。注意:sample函数不会修改原有序列
>>> li=[1,2,3,4,5,6]
>>> random.sample(li,4)
[4, 2, 5, 3]
>>> random.sample(li,3)
[3, 2, 1]
>>> random.sample(li,5)
[3, 5, 2, 1, 4]
>>> print(li)
[1, 2, 3, 4, 5 6]
>>>

20.Python流程控制

IF条件分支语句
Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块。
  • if单分支语句
if 逻辑语句:
语句(块)
demo:
print(111)
if True:
    print(222)
print(333)
运行:
111
222
333
如果改成如下:
print(111)
if False:
    print(222)
print(333)
运行:
111
333
将True或者False换成逻辑语句。
if多分支语句
Python 中用 elif 代替了 else if,所以if语句的关键字为:if – elif – else。
注意:
- 1.每个条件后面要使用冒号 :,表示接下来是满足条件后要执行的语句块。
- 2.使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块。
- 3.在Python中没有switch – case语句。

21.执行的三种方式:

一、进入脚本文件所在文件夹运行程序
  • 方法一:
Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。

C:\Users\Administrator>cd E:\day06

C:\Users\Administrator>e:

E:\day06>python day6.py
请输入你猜的数字(1or2):2
Sorry, 你猜错了
1

E:\day06>
  • 方法二:
Shift+鼠标右键,打开命令窗口
  • 按照对应路径运行脚本
    • 方法三
C:\Users\Administrator>python E:\day06\day6.py
请输入你猜的数字(1or2):2
Sorry, 你猜错了
1

C:\Users\Administrator>

22.while语句

  • 概念:循环用来执行部分代码-----即在一定的条件下执行重复的代码
  • 格式
    while 逻辑语句:
       语句()
    demo:

    1.打印 1 - 100

23.字符串(String)

  • 什么是字符串:
    字符串是python中最常用的数据类型,是用引号来创建字符串的,最常用的有单引号,双引号,三单引号,三双引号
    name = "Changsha" #双引号
    age = "5000" #只要加双引号就是字符串
    age_1 = 5000 #不加,整形
    msg = """I'm in Changsha""" #三双引号
    msg_1 = '''I'm in Hengyang''' #三单引号
    hometowm = 'Changsha' #单引号
    print(type(name),type(age),type(age_1),type(msg),type(msg_1),type(hometowm),sep="|")
    
    <class 'str'>|<class 'str'>|<class 'int'>|<class 'str'>|<class 'str'>|<class 'str'>
    多引号什么作用呢?作用就是多行字符串必须用多引号。
    msg = """
    轻轻的我走了,
    正如我轻轻的来;
    我轻轻的招手,
    作别西天的云彩,
    """
    print(msg)
    字符串运算及操作
    数字可以进行加减乘除运算,字符串呢?让我大声告诉

    你,也能?what?是的,但只能进行“相加”和“相乘”运算。

    (1)拼接(+)
    a = "Hello"
    b = "Python"
    a+b
    ‘HelloPython’
    注意,字符串的拼接是双方都是字符串,不能跟数字
    或其他类型拼接
    age_1 = 5000
    name+age_1
    错
    (2)重复(*)
    a = "Hello" /
    a*3
    'HelloHelloHello'
    (3)字符串索引([]以及切片[::])

>>> a = "Life is short, I use python"
>>> len(a) #查询a字符串的总长度
27
>>> a[0]
'L'
>>> a[15]
'I'
>>> a[-1]
'n'
>>> a[-6]
'p'
>>> #切片
...
>>> a[:13] #0到12索引的所有值
'Life is short'
>>> a[15:] #从索引15到最后的值
'I use python'
>>> a[15::2] #从索引值15开始,步长为2,每次跳过一个元素,一直到最后
'Iuepto'
>>> a[::-1] #逆序输出
'nohtyp esu I ,trohs si efiL'
>>> a[::-2] #负数就是从右往左取,取偶数
'nhy s  toss fL'
(4)大小写转换
  • str.lower():转小写
  • str.upper():转大写
  • str.swapcase():大小写转换

  • str.capitalize():字符串首为大写,其余小写
  • str.title():以分隔符为标记,首字符为大写,其余为小写
    >>> a = "Life is short, I use python"
    >>> a.lower() #转小写
    'life is short, i use python'
    >>> a.upper() #转大写
    'LIFE IS SHORT, I USE PYTHON'
    >>> a.swapcase() #大写变小写,小写变大写
    'lIFE IS SHORT, i USE PYTHON'
    >>> a.capitalize() #字符串首为大写,其余小写
    'Life is short, i use python'
    >>> a.title() #以分隔符为标记,首字符为大写,其余为小写
    'Life Is Short, I Use Python'
    >>>
  • 应用:验证码不区分大小写
    a = "LIFE"
    c = input("请输入一个验证码")
    if a.lower() == c.lower():
    	print("输入的验证码正确")
    else:
    	print("输入的验证码错误")
    (5)字符串格式输出对齐
  • str.center()
  • str.ljust()
  • str.rjust()
  • str.zfill()
>>> a = "Life is short, I use python" #总长度27,写了35,就是35减27=8然后填充8个指定填充的东西
>>> a.center(35,'*') #返回一个原字符串居中,并使用空格填充长度(width)的新字符串
'****Life is short, I use python****'
>>> a.ljust(35,'*') #返回一个原字符串左对齐,并使用空格填充至长度(width)的新字符串
'Life is short, I use python********'
>>> a.rjust(35,'*') #返回一个原字符串右对齐,并使用空格填充至长度(width)的新字符串
'********Life is short, I use python'
>>> a.zfill(35) #返回长度为(width)的字符串,原字符串String右对齐,前面填充0,只有一个参数
'00000000Life is short, I use python'
>>>
(6)删除指定字符
  • str.lstrip():删除左边的指定字符串
  • str.rstrip():删除右边的指定字符串
  • str.strip():删除两边的指定字符串
  • 注意空格也行
>>> a = "****Life is short, I use python****"
>>> a.lstrip("*")
'Life is short, I use python****'
>>> a.rstrip("*")
'****Life is short, I use python'
>>> a.strip("*")
'Life is short, I use python'
>>>
(7)计数
=COUNTIF(B2:B31,">=30")/COUT(B2:B31)
>>> a = "Life is short, I use python"
>>> a.count('i') #返回str在string里面出现的次数
2
>>> a.count('i',4,8) #在索引值为[4,8]的范围内str出现的次数
1
(8)字符串搜索定位与替换
  • str.find()
    >>> a = "Life is short, I use python"
    >>> a.find('e') #查找元素并返回第一次出现的元素的索引值
    3
    >>> a.find('e',18,24) #查找元素在指定索引范围内的索引
    19
    >>> a.find('w') #找不到值返回-1
    -1
    >>>
  • str.index()
    • 和find()方法一样,只不过如果str不在string中会报一个异常
      >>> a = "Life is short, I use python"
      >>> a.index('e')
      3
      >>> a.index('e',18)
      19
      >>> a.index('w')
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      ValueError: substring not found
      >>>
  • str.replace():替换
    >>> a = "Life is short, I use python"
    >>> a.replace('I use','You need')
    'Life is short, You need python'
    >>> a.replace('t','T')
    'Life is shorT, I use pyThon'
    >>> a.replace('t','T',2) #两次出现的小写't'换成大写'T'
    'Life is shorT, I use pyThon'
    >>>
    (9)字符串条件判断
    • isalnum(),字符串由字母或数字组成,
    • isalpha(),字符串只由字母组成,
    • isdigit(),字符串只由数字组成
    In [1]: a = "abc123"
    
    In [2]: b = "ABC"
    
    In [3]: c = 123
    
    In [4]: a.isalnum()
    Out[4]: True
    
    In [5]: a.isalpha()
    Out[5]: False
    
    In [6]: a.isdigit()
    Out[6]: False
    
    In [7]: b.isalnum()
    Out[7]: True
    
    In [8]: b.isalpha()
    Out[8]: True
    
    In [9]: b.isdigit()
    Out[9]: False>>> str = '01234'
     
    >>> str.isalnum()                #是否全是字母和数字,并至少有一个字符
    True
    >>> str.isdigit()                #是否全是数字,并至少有一个字符
    True      
     
     
    >>> str = 'string'
     
    >>> str.isalnum()                  #是否全是字母和数字,并至少有一个字符
    True
    >>> str.isalpha()                  #是否全是字母,并至少有一个字符 
    True
    >>> str.islower()                  #是否全是小写,当全是小写和数字一起时候,也判断为True
    True
     
    >>> str = "01234abcd"
     
    >>> str.islower()                  #是否全是小写,当全是小写和数字一起时候,也判断为True
    True
     
    >>> str.isalnum()                  #是否全是字母和数字,并至少有一个字符
    True
     
    >>> str = ' '
    >>> str.isspace()                  #是否全是空白字符,并至少有一个字符
    True
     
    >>> str = 'ABC'
     
    >>> str.isupper()                  #是否全是大写,当全是大写和数字一起时候,也判断为True
    True
     
    >>> str = 'Aaa Bbb'
     
    >>> str.istitle()                  #所有单词字首都是大写,标题 
    True
     
     
    >>> str = 'string learn'
     
    >>> str.startswith('str')                 #判断字符串以'str'开头
    True
     
    >>> str.endswith('arn')                      #判读字符串以'arn'结尾
    True
(10)制表符转换
  • str.expandtabs()
>>> a = "L\tife is short, I use python"
>>> a.expandtabs() #默认将制表符转化为8个空格
'L       ife is short, I use python'
>>> a.expandtabs(4) #加上参数,将制表符转化为对应个数的空格
'L   ife is short, I use python
>>>
(11)ASCll码和字符的转化
  • chr():用一个范围range(256)内的(就
    是0-255)整数作参数,返回一个对应的
    字符。
  • ord():将一个ASCll字符转换为对应的数字
(12)字符串分隔变化
  • join()将指定字符插入到元素之间
  • split()以指定字符分割序列且去除该字符
  • partition()以指定字符分割序列且包含该字符
>>> str = "learn string"
>>> "-".join(str)
'l-e-a-r-n- -s-t-r-i-n-g'
>>> li = ["learn","string"]
>>> '-'.join(str)
'l-e-a-r-n- -s-t-r-i-n-g'
>>> '-'.join(li)
'learn-string'
>>> str.split('n')
['lear', ' stri', 'g']
>>> str.split('n',1)
['lear', ' string']
>>> str.rsplit('n')
['lear', ' stri', 'g']
>>> str.rsplit('n',1)
['learn stri', 'g']
>>> str.splitlines()
['learn string']
>>> str.partition('n')
('lear', 'n', ' string')
>>>
23.1 string模块
string模块中的capwords()函数功能
  • string模块中的capwords()函数功能:
    • 1.将每个单词首字母置为大写
    • 2.将每个单词除首字母外的字母均置为小写;
    • 3.将词与词之间的多个空格用一个空格代替
    • 4.其拥有两个参数,第二个参数用以判断单词之间的分割符,默认为空格。
>>> import string
>>> dir(string)
['Formatter', 'Template', '_ChainMap', '_TemplateMetaclass', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_re', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']

>>> string.ascii_letters 
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.capwords('HUNAN yingxiao college')
'Hunan Yingxiao College'
>>>
>>> import string
>>> dir(string)
['Formatter', 'Template', '_ChainMap', '_TemplateMetaclass', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_re', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']
>>> string.digits
'0123456789'
>>> string.hexdigits
'0123456789abcdefABCDEF'
>>> string.octdigits
'01234567'
>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'
>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>>

24.格式输出

你怎么实现呢?你会发现,用字符拼接的方式还难实现这种格式的输出,所以一起来学一下新姿势
只需要把要打印的格式先准备好, 由于里面的 一些信息是需要用户输入的,你没办法预设知道,因此可以先放置个占位符,再把字符串里的占位符与外部的变量做个映射关系就好啦。
PS E:\python\python课堂练习> python 格式输出.py
Name:name
Age:age
Job:job
Hobbie:hobbie

--- info of name ---
Name  :  name
Age   :  age
job   :  job
Hobbie:  hobbie
------end-------


PS E:\python\python课堂练习>
    
li = []
for i in range(3):
    dic={}
    name = input("姓名:")
    age = input("年龄:")
    job = input("工作:")
    hobble = input("爱好:")
    dic["姓名"] = name
    dic["年龄"] = age
    dic["工作"] = job
    dic["爱好"] = hobble
    #print(dic)
    li.append(dic)
print(li)
对格式进行进一步的控制:
可以用如下的方式,对格式进行进一步的控制:
%(name)[width].[precision]typecode
(name)为命名
flags可以有+,-,’ ‘或0。+表示右对齐。-表示左对齐。’ '为一个空格,表示在正数的左侧填充一个空格,从而与负数对齐。0表示使用0填充。
width表示显示宽度
precision表示小数点后精度
>>> "His name is %s\n his age is %d" % ("Tom", 18)
'His name is Tom\n his age is 18'
>>> print("His name is %s\n his age is %d" % ("Tom", 1
His name is Tom
 his age is 18
>>>
>>> "His name is %s\n his age is %d" % ("Tom", 18)
'His name is Tom\n his age is 18'
>>> print("His name is %s\n his age is %d" % ("Tom", 18))
His name is Tom
 his age is 18
>>> print(r"His name is %s\n his age is %d" % ("Tom", 18))
His name is Tom\n his age is 18
>>>

24.1数据类型的互相转换

>>> a=['a','b','c']
>>> b=['d','e','f']
>>> tuple(a)
('a', 'b', 'c')
>>> tuple(b)
('d', 'e', 'f')
>>> list(a)+list(b)
['a', 'b', 'c', 'd', 'e', 'f']
>>> a+b
['a', 'b', 'c', 'd', 'e', 'f']
>>> str(tuple(a))
"('a', 'b', 'c')"
>>> str(list(b))
"['d', 'e', 'f']"
>>>

25."%"是Python风格的字符串格式化操作符,非常类似C语言里的printf()函数的字符串格式化(C语言中也是使用%)。

下面整理了一下Python中字符串格式化符合:
格式化符号说明
%c转换成字符(ASCII 码值,或者长度为一的字符串)
%r优先用repr()函数进行字符串转换
%s优先用str()函数进行字符串转换
%d / %i转成有符号十进制数
%u转成无符号十进制数
%o转成无符号八进制数
%x / %X转成无符号十六进制数(x / X 代表转换后的十六进制字符的大小写)
%e / %E转成科学计数法(e / E控制输出e / E)
%f / %F转成浮点数(小数部分自然截断)
%g / %G%e和%f / %E和%F 的简写
%%输出% (格式化字符串里面包括百分号,那么必须使用%%)
这里列出的格式化符合都比较简单,唯一想要强调一下的就是"%s"和"%r"的差别。
看个简单的代码: 格式化操作符
>>> a = 15
>>> print(("%d to hex is %x")% (a,a))
15 to hex is f
>>> "%x" % 15
'f'
>>> "%f" % 15
'15.000000'
>>> "%e" % 15000
'1.500000e+04'
>>> "%d" % 100
'100'
>>> "%d%%" %  100
'100%'
>>>

26.列表

列表是python中的基础数据类型之一,其他语言中也有类似于列表的数据类型,比如js中叫数组,他是以[]括起来,每个元素以逗号隔开,而且他里面可以存放各种数据类型比如:
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串,不仅可以储存不同的数据类型,而且可以储存大量数据,32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的,有索引值,可切片,方便取值。
特点: 是一个有序的,可以重复的序列,可变类型。
1.创建一个空列表
list1 = []
print(type(list1)
2.创建一个由多个值的列表,每个值用逗号隔开
注意:列表也可以存放不同类型的元素
list1 = [15,"六",[1,2,3],(22,33),{'name':'Tom','age':18}]
3.列表的拼接
lisst + list
4.列表的重复
list * 3
5.列表的索引和切片
>>> list2 = [18,"str",[1,2,3],(55,56),{'name':'Tom','age':18}]
>>> len(list2)
5
>>> list2[2]
[1, 2, 3]
>>> list2[-1]
{'name': 'Tom', 'age': 18}
>>> list2[3:]
[(55, 56), {'name': 'Tom', 'age': 18}]
>>> list2[0::2]
[18, [1, 2, 3], {'name': 'Tom', 'age': 18}]
>>>

26.1列表常见操作

列表:
names = ['a','b','c']
1.增加
  • append():增加到最后
  • extend():迭代的去增
  • insert():按照索引去增加
#append(),增加到最后
>>> names = ['a','b','c']
>>> names.append('e')
>>> names
['a', 'b', 'c', 'e']
>>>
#extend():迭代的去增
>>> names = ['a','b','c']
>>> place = ['er','wr']
>>> names.extend(place)
>>> names
['a', 'b', 'c', 'er', 'wr']
>>>
#insert,按照索引去增加
>>> names.insert(2,'devilf')
>>> names
['a', 'b', 'devilf', 'c', 'e']
>>>
#其它的插入方法:
>>> names[3] = 'lebron'
>>> names
['a', 'b', 'c', 'lebron', 'wr']
>>>
2.删除
  • pop()
  • remove():移除指定元素
  • del():删除指定索引的元素
  • clear():删除所有元素
    #pop
    >>> names = ['a','b','c']
    >>> names.pop() #如果没有指定下标,则默认会删除最后一个元素
    'c'
    >>> names
    ['a', 'b']
    >>> names.pop(1) #指定索引时,就会删除索引所对应的元素
    'b'
    >>> names
    ['a']
    >>>
    #remove()移除指定元素
    >>> names =['a','b','c','d','e']
    >>> names.remove('d')
    >>> names
    ['a', 'b', 'c', 'e']
    >>>
    #del删除指定索引的元素
    >>> names = ['a','b','c','d','e']
    >>> del names[4]
    >>> names
    ['a', 'b', 'c', 'd']
    >>>
    >>> names = ['a','b','c','d','e']
    >>> names.clear()
    >>> names
    []
    >>>
    3.改
>>> li = ['a','b','c','d']
>>> li[1] = 'cc'
>>> li
['a', 'cc', 'c', 'd']
>>> li[0:2] = ['aa','bb']
>>> li
['aa', 'bb', 'c', 'd']
>>>
4.查
切片去查,或者,循环去查
5.其它操作:
1.查找元素所在位置:index()
>>> names = ['a','b','c']
>>> names.index('c')
2
2.统计·元素的次数:count()
>>> names.append('b')
>>> names.count('a')
1
3.反转:reverse()
#方式一
>>> names.reverse()
>>> names
['b', 'c', 'b', 'a']
>>>

#方式二
>>> names = ['a','b','c']
>>> names[::-1]
['c', 'b', 'a']
>>>
4.排序:sort()按照ascii码来进行排序
>>> names=['a','b','c','d','e']
>>> names.insert(3,'&&')
>>> names
['a', 'b', 'c', '&&', 'd', 'e']
>>> names.sort()
>>> names
['&&', 'a', 'b', 'c', 'd', 'e']
>>> names.sort(reverse=True)
>>> names
['e', 'd', 'c', 'b', 'a', '&&']
>>>
5.对列表进行切片处理
  • 1)列表所有的元素
>>> names=['a','b','c','d','e']
>>> names[::]
['a', 'b', 'c', 'd', 'e']
>>>
  • 2)列出最后一个元素,从中间位置开始,列出后面所有的元素
>>> names=['a','b','c','d','e']
>>> names[-1]
'e'
>>>
names=['a','b','c','d','e']
>>> a=int(len(names)/2)
>>> names[a:]
['c', 'd', 'e']
>>>

27.format格式化{}

  • 位置映射
    >>> print("{}:{}".format("Xiaoming",18))
    Xiaoming:18
    >>> print("His name is{}, his age is {}".format("Xiaoming",18))
    His name isXiaoming, his age is 18
    >>>
  • 关键字映射
>>> print("{name},+++++,{age},+++++,{name}".format(name = "Xiaoming",age = 18))
Xiaoming,+++++,18,+++++,Xiaoming
>>>
  • 元素访问
    >>> print("{0[0]}----{0[1]}-----{1[0]}----{1[1]}".format(["python","java"],["C++","R Language"]))
    python----java-----C++----R Language
    >>>

28.元组(tuple)

1.概念:是一个有序的,可重复的,不可更改的对象
特点:
    1.与list类似
    2.不可变类型数据
    3.元组使用的是()

基本描述:
    元组是用()包裹起来的多个元素的数据类型,每个元素之间用","隔开;
2.元组的基本使用格式:
(元素1,元素2,...,元素n)
3.元组的创建
  • 创建一个空元组
    >>> t1 = ()
    >>> type(t1)
    <class 'tuple'>
    >>>
  • 创建只含有一个元素的元组
    需要注意的地方是:如果我们创建只含有一个元素的元组,我们必须在这仅有的一个元素后加上一个","
>>> t2 = (12,)
>>> type(t2)
<class 'tuple'>
>>>
  • 创建含有多个元素的元组
    >>> t1 = (1,2,3,4,5)
    和列表一样,元组的元素也可以是不同的数据类型的元素
tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
4.元组的基本操作
  • 通过索引值查找对应的元素
>>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
>>> tl[4]
{'name': 'Tom', 'age': 18}
>>> tl[-1]
{'name': 'Tom', 'age': 18}
>>> tl[::-2]
({'name': 'Tom', 'age': 18}, ['h', 'u', 'n', 'a', 'n'], 1)
>>> t1 = (1,"human",['h','u','n','a','n'])
>>> t1[2][2]
'n'
>>>
  • 查找元素的索引值
>>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})
>>> tl.index("hunan")
1
>>> tl.index("hunan",1,4)
1
>>>
注意:元组是不可变的数据类型:不能够增,删,改
>>> t1 = (1,"hunan",['h','u','n','a','a'],('I','love','python'),{"name":"Tom","age":18})
>>> t1[0] = 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignmen
>>>
注意到t1里有个列表,那么这个列表中的元素是否可以更改
>>> t1 = (1,"hunan",['h','u','n','a','a'],('I','love','python'),{"name":"Tom","age":18})
>>> t1[2]
['h', 'u', 'n', 'a', 'a']
>>> t1[2][2] = "N"
>>> t1
(1, 'hunan', ['h', 'u', 'N', 'a', 'a'], ('I', 'love', 'python'), {'name': 'Tom', 'age': 18})
>>>
5.拼接
>>> t1 = ('a','b','c')
>>> t2 = ('d','e','f')
>>> t1 + t2
('a', 'b', 'c', 'd', 'e', 'f')
>>>
6.重复
>>> t1 = ('a','b','c')
>>> t1 * 3
('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')
>>>
7.判断元素是否存在
>>> t1 = ('a','b','c')
>>> 'a' in t1
True
>>> 'a' not in t1
False
>>>
8.内置函数(最大值最小值)
>>> tu = ("a", "b", "c")
>>> max(tu)
'c'
>>> min(tu)
'a'
>>>
9.元组的遍历
1 ) 值遍历
>>> tp = ("Python","java","C++")
>>> for i in tp:
...     print(i,end= " ")
...
Python java C++ >>>

2 ) 索引遍历

>>> tp = ("Python","java","C++")
>>> for i in range(len(tp)):
...     print(tp[i],end= " ")
...
Python java C++ >>>
3 ) 索引-值,遍历
枚举(enumerate),对于一个可迭代的(iterable)/可遍历的对象(如列表,字符串),enumerate将其组成一个索引序列,利用它可以同时获得索引和值
#不带参
>>> tp = ("Python","java","C++")
>>> for index, value in enumerate(tp):
...     print(index,":",value)
...
0 : Python
1 : java
2 : C++
>>>

#带参
>>> tp = ("Python","java","C++")
>>> for index, value in enumerate(tp,3):
...     print(index,":",value)
...
3 : Python
4 : java
5 : C++
>>>
10.二维元组
>>> tp = ((1,2,3),(4,5,6),(1,3))
>>> tp[1][1]
5
11.三维元组
>>> tp = (((1,2,3),(4,5,6),(1,3)),
...    ((1,2,3),(4,"Hunan",6),(7,8,9)),
... ((1,2,3),(4,5,6),(7,8,9)))
>>> tp[0][1][1]
5
>>>

Kindle

  • mobi

29.字典

思考:
场景1
如果有列表
li = ['python','java','C++']
需要对“python”这个名字写错了,通过代码修改:
li[0] = "Python"
如果列表的顺序发生了变化,如下
li = ['java','C++','Python];
此时就需要修改下标才能完成名字的修改
li[2] = "Python"
有没有方法,既能存储多个数据,还能在访问元素的很方便就能够定位到需要的那个元素呢?
答:
字典
场景2:
学生信息列表,每个学生信息包括学号,姓名,年龄等,如何从中找到某个学生的信息?
>>> studens= [231531,"张三",18],[564665"李四",19],....]
循环遍历?这样很麻烦.
实际生活中,我们还经常使用汉语字典,英汉词典等等.
程序中的字典:
   info = {"usrname":"Lilei", "age": 18, "Class": "one"}
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。字典是一种可变数据类型,且可存储任意类型对象。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
格式:
	{key1:value1,key2:value2,....}
描述:
1.键-值对中间用冒号(":")连接;
2.key:value组成字典里的一个元素;
3.键-值对(元素)之间用逗号(",")隔开;
4.整个字典用花括号"{}"包裹起来

29.1字典的创建

创建一个空字典

dict = {}
type(dict)

创建一个有多个值的字典

1.直接赋值法:d = {key1:value1,key2:value2},如
>>> info = {"usrname":"Lilei","age":18,"Class":"one"}
>>> info
{'usrname': 'Lilei', 'age': 18, 'Class': 'one'}
>>>
2.通过函数创建字典(强制转换):
>>> info = dict(usrname = "Lilei", age = 18, Class = "one")
>>> info
{'usrname': 'Lilei', 'age': 18, 'Class': 'one'}
>>> info = dict([['name', 'LiLei'], ['age', 18]])
>>> info
{'name': 'LiLei', 'age': 18}
>>> info = dict((('name', 'LiLei'), ('age', 18)))
>>> info
{'name': 'LiLei', 'age': 18}
>>> info = dict([('name', 'LiLei'), ('age', 18)])
>>> info
{'name': 'LiLei', 'age': 18}
>>> info = dict((['name', 'LiLei'], ['age', 18]))
>>> info
{'name': 'LiLei', 'age': 18}
>>>
3.通过字典的fromkeys方法创建字典
>>> info = dict.fromkeys("Hello") #如果没有指定默认值,默认为None;
>>> info
{'H': None, 'e': None, 'l': None, 'o': None}
>>> info = dict.fromkeys(["Lilei","Lee","Jack"],"123456") #给每个元素设置默认值为"123456";
>>> info
{'Lilei': '123456', 'Lee': '123456', 'Jack': '123456'}
>>>

29.2字典的常见操作

字典值的访问(查的一种)

#字典是无序的,不能通过索引值来获取值
>>> info = info[2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 2
>>>
  • 通过键(key)访问值(value)
    • key值不存在的时候,会报错
>>> info = {"usrname":"Lilei","age":18,"Class":"one"}
>>> info["usrname"] #通过关键字访问对应的值
'Lilei'
>>> info["age"]
18
>>> info["usname"] #没有对应的key,报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'usname'
>>>
  • 使用get访问值(value)
    不确定字典中是否存在某个键而又想获得其值时,可以使用get方法,还
    可以设置默认值
    • 当key不存在的,不会抛出异常,返回None。
    >>> info = {"name":"LiLei","age":18}
    >>> info.get("name")
    'LiLei'
    #当key不存在,不会抛出异常,返回None
    >>> info.get("job")
    >>> type(info.get("job"))
    <class 'NoneType'>
    >>>
  • 直接添加新键-值对
    在使用 变量名[‘键’] = 数据 时,这个“键”在字典中,不存在,那么就会新增这个元素:
>>> info = {"name":"LiLei","age":18}
>>> info["job"] = "IT"
>>> info
{'name': 'LiLei', 'age': 18, 'job': 'IT'}
>>>
  • dict.update(info1)
    把字典info1的键/值对更新到info里
    • 当两个字典中的键不同时,把info1的键值插入到info中
    • 当两个字典中存在相同键时,info1覆盖dit的键值
#当两个字典完全不相同时
>>> info = {"name":"LiLei","age":18}
>>> info1 = {"job":"IT","salary":100000}
>>> info.update(info1)
>>> info
{'name': 'LiLei', 'age': 18, 'job': 'IT', 'salary': 100000}
>>> info
{'name': 'LiLei', 'age': 18, 'job': 'IT', 'salary': 100000}
>>> info1
{'job': 'IT', 'salary': 100000}
>>>

#当两个字典存在相同键时,会覆盖前面的键值
>>> info = {"name":"LiLei","age":18}
>>> info2 = {"name":"Tom","salary":10000}
>>> info.update(info2)
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000}
>>>
>>> info2
{'name': 'Tom', 'salary': 10000}
>>>
  • del dict[keys]
    • 删除指定的元素/键-值对
    • 没有返回值
>>> info = {'name':'Tom','age':18,'salary':10000}
>>> del info["salary"]
>>> info
{'name': 'Tom', 'age': 18}
>>>
  • del dict
    • 删除整个字典
>>> info = {'name':'Tom','age':18,'salary':10000}
>>> del info
>>> info
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'info' is not defined
>>>
  • dict.clear()
    • 清空整个字典
>>> info = {'name':'LiLei',"age":18}
>>> info.clear()
>>> info
{}
>>>
  • dict.pop(keys)
    • 删除指定键-值对
>>> info = {'name':'Tom','age':18,'salary':10000}
>>> info.pop("age")
18
>>> info
{'name': 'Tom', 'salary': 10000}
>>>
  • dict.popitem()
    • 随机删除字典中的一组键值对
    • 有返回值,以元组方式返回
    • 应用不广泛
>>> info = {'name':'Tom','age':18,'salary':10000}
>>> info.popitem()
('salary', 10000)
>>> info
{'name': 'Tom', 'age': 18}
>>>
字典的每个元素中的数据是可以修改的,只要通过key找到,即可修改
  • 直接修改
>>> info = {'name':'Tom','age':18,'salary':10000}
>>> info["name"] = "LiLei"
>>> info
{'name': 'LiLei', 'age': 18, 'salary': 10000}
>>>
  • dict.setdefault()
    • 键存在,不改动,返回字典中相应的值
    • 键不存在,在字典中添加相应的键值对,并返回相应的值
# 键存在,不改动,返回字典中相应的值
>>> info = {'name':'Tom','age':18,'salary':10000}
>>> info.setdefault("age",20)
18
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000}
>>>

# 键不存在,在字典中添加相应的键值对,并返回相应的值
>>> info = {'name':'Tom','age':18,'salary':10000}
>>> info.setdefault("job","IT")
'IT'
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000, 'job': 'IT'}
>>>
  • dict.keys()
    • 返回字典中的所有键(keys)
  • dict.values()
    • 返回字典中的所有值(values)
  • dict.items()
    • 返回字典中的所有键-值对(keys-values)
  • 某元素是否存在:
    • key in dict
      • 存在,True

      • 不存在,False

        Python2中,可以用dict.has_key(),如果key在字典中,返回True;否则,返回False
>>> info = {'name':'Tom','age':18,'salary':10000}
>>> info.keys()
dict_keys(['name', 'age', 'salary'])
>>>
>>> info.values()
dict_values(['Tom', 18, 10000])
>>>
>>> info.items()
dict_items([('name', 'Tom'), ('age', 18), ('salary', 10000)])
>>>
>>> "age" in info
True
>>> "job" in info
False
>>>

29.3字典的遍历

(1)遍历字典的键(keys)
>>> info = {"usrname":"Lilei","age":18,"Class":"one"}
>>> for key in info.keys():
...     print(key,end=" ")
...
usrname age Class >>>
(2)遍历字典的值(values)
>>> info = {"usrname":"Lilei","age":18,"Class":"one"}
>>> for value in info.values():
...     print(value,end = " ")
...
Lilei 18 one >>>
(3)遍历所有的项(items)
>>> info = {"usrname":"Lilei","age":18,"Class":"one"}
>>> for item in info.items():
...     print(item,end =" ")
...
('usrname', 'Lilei') ('age', 18) ('Class', 'one') >>>
(4)遍历字典的键-值对(key-value)
>>> info = {"usrname":"Lilei","age":18,"Class":"one"}
>>> for key,value in info.items():
...     print(key,":",value,end = " ")
...
usrname : Lilei age : 18 Class : one >>>
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值