当前位置:   article > 正文

python3:基础语法、及6种基本数据类型、找到字典的下标 index、获取list中指定元素的位置索引_python3 字典 index

python3 字典 index

基础语法

源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串

Python 3 中,可以用中文作为变量名,非 ASCII 标识符也是允许的

标识符

第一个字符必须是字母表中字母或下划线 _

标识符的其他的部分字母、数字和下划线组成。

标识符对大小写敏感

注释

# 第一个注释
# 第二个注释

'''
第三注释
第四注释
'''


"""
第五注释
第六注释
"""
print("Hello, Python!")

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

行与缩进

缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数

如下:最后一行语句缩进数的空格数不一致,会导致运行错误:,如果使用编译器应该会提示的

if True:
    print("Answer")
    print("True")
else:
    print("Answer")
 print("False")  # 缩进不一致,会导致运行错误
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

空行

函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。

空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。

print 输出

print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=""

end="xxx",表名以xxx代替换行符

# 换行输出
print(x)
print(y)

print('---------')
# 不换行输出
print(x, end=" ")
print(y, end=" ")
print("xxx")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

输出

a
b
---------
a b xxx
  • 1
  • 2
  • 3
  • 4

其还支持参数格式化,与 C 语言的 printf 类似,如下

str = "the length of (%s) is %d" % ('?ABC!', len('?ABC!'))
print(str)

pi = 3.141592653
print('%10.3f' % pi)  # 字段宽10,精度3
print("pi = %.*f" % (3, pi))  # 用*从后面的元组中读取字段宽度或精度
print('%010.3f' % pi)  # 用0填充空白
print('%-10.3f' % pi)  # 左对齐
print('%+f' % pi)  # 显示正负号
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

输出

the length of (?ABC!) is 5
     3.142
pi = 3.142
000003.142
3.142     
+3.141593
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

python字符串格式化符号:
在这里插入图片描述

input输入

input() 函数的参数只能为单个字符串input() 返回一个字符串,对字符串使用 split(" ") 可对其按空格切分。
如下代码所示

#输入三角形的三边长
a,b,c = (input("请输入三角形三边的长:").split())
a= int(a)
b= int(b)
c= int(c)

#计算三角形的半周长p
p=(a+b+c)/2

#计算三角形的面积s
s=(p*(p-a)*(p-b)*(p-c))**0.5

#输出三角形的面积
print("三角形面积为:",format(s,'.2f'))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

import 与 from…import

** 用 import 或者 from…import 来导入相应的模块**

  • 整个模块(somemodule)导入,格式为: import somemodule
  • 从某个模块中导入某个函数,格式为: from somemodule import somefunction
  • 某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc
  • 某个模块中的全部函数导入,格式为: from somemodule import *

python3的6种基本数据类型

为变量赋值

Python允许同时为多个变量赋值,如下

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

a, b, c = 1, 2, "runoob"
print(a)
print(b)
print(c)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

输出

=========
1
1
1
=========
1
2
runoob
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

不可变数据(3 个)

1、Number(数字):int、float、bool、complex(复数)

只有一种整数类型 int,表示为长整型

Python3 中,bool 是 int 的子类,True 和 False 可以和数字相加, True==1、False==0 会返回 True

print(issubclass(bool, int))
print(True == 1)
print(False == 0)
print(True + 1)
print(False + 1)
print(int(True))
print(int(False))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

输出

True
True
True
2
1
1
0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2、String(字符串)

字符串用单引号 ’ 或双引号 " 括起来,同时使用反斜杠 \ 转义特殊字符,注意:

  1. 反斜杠可以用来转义,使用r可以让反斜杠不发生转义
  2. 字符串可以用+运算符连接在一起,用*运算符重复
  3. Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始
  4. Python中的字符串不能改变

字符串的截取的语法格式

变量[头下标:尾下标]
  • 1

索引值以 0 为开始值,-1 为从末尾的开始位置

str = '123456'
print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次,也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串
print('123\n456')   # 换行
print(r'123\n456')  # 不换行
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

输出

123456
12345
1
345
3456
123456123456
123456TEST
123
456
123\n456
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

3、Tuple(元组)

Python 的元组与列表类似,不同之处在于元组的元素不能修改

元组使用小括号 ( ),列表使用方括号 [ ]

元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

tup = (1, 2, "xxx", 4, 5)
print(type(tup))
# 创建空元组
tup1 = ()
  • 1
  • 2
  • 3
  • 4

输出

<class 'tuple'>
  • 1

元组中只包含一个元素时,需要在元素后面添加逗号 , ,否则括号会被当作运算符使用

tup1 = (50)
print(type(tup1))

tup2 = (50,)
print(type(tup2))
  • 1
  • 2
  • 3
  • 4
  • 5

输出

<class 'int'>
<class 'tuple'>
  • 1
  • 2

元组与字符串类似,下标索引从 0 开始,可以进行截取,组合等

在这里插入图片描述

访问修改删除元组

元组中的元素值是不允许修改的,但我们可以对元组进行连接组合

元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组

tup1 = ('abc', '?!', 1997, 2000)
# 访问
print("tup1[0]: ", tup1[0])
# 修改:元组中的元素值是不允许修改的,但我们可以对元组进行连接组合
'''
# 以下修改元组元素操作是非法的。
tup1[0] = "?abc!"
'''
# 正确修改
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print(tup3)
del tup3
print("删除后的元组 tup3 : ")
# 现在打印会抛出异常
print(tup3)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

输出

tup1[0]:  abc
('abc', '?!', 1997, 2000, 'abc', 'xyz')
删除后的元组 tup3 : 
Traceback (most recent call last):
  File "D:\testCode\pythonCodeTest\test\testGrammar.py", line 21, in <module>
    print(tup3)
          ^^^^
NameError: name 'tup3' is not defined. Did you mean: 'tup1'?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

可变数据(3 个)

4、List(列表)

创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可,如下

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
  • 1

与字符串的索引一样,列表索引从 0 开始,第二个索引是 1,依此类推。
在这里插入图片描述

索引也可以从尾部开始,最后一个元素的索引为 -1,往前一位为 -2,以此类推。
在这里插入图片描述

通过索引列表可以进行截取、组合等操作

使用下标索引来访问列表中的值,同样你也可以使用方括号 [] 的形式截取字符,如下所示:
在这里插入图片描述

访问更新删除列表
访问
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list[0])
print(list[-2])
print(list[0:4])
print(list[1:-2])
  • 1
  • 2
  • 3
  • 4
  • 5

输出

red
white
['red', 'green', 'blue', 'yellow']
['green', 'blue', 'yellow']
  • 1
  • 2
  • 3
  • 4
更新
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
list[0] = 1
print(list)
list.append(7)
print(list)
  • 1
  • 2
  • 3
  • 4
  • 5

输出

[1, 'green', 'blue', 'yellow', 'white', 'black']
[1, 'green', 'blue', 'yellow', 'white', 'black', 7]
  • 1
  • 2
删除
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
del list[0]
print(list)
  • 1
  • 2
  • 3

输出

['green', 'blue', 'yellow', 'white', 'black']
  • 1
比较

列表比较需要引入 operator 模块的 eq 方法

import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a, b))
print("operator.eq(c,b): ", operator.eq(c, b))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

输出

operator.eq(a,b):  False
operator.eq(c,b):  True
  • 1
  • 2
其他

在这里插入图片描述

5、Set(集合)

集合(set)是一个无序的不重复元素序列,可以使用大括号 { } 或者 set() 函数创建集合

创建格式
parame = {value01,value02,...}
# 或者
set(value)
  • 1
  • 2
  • 3
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
添加元素
add

将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。

s.add( x )
  • 1

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}
  • 1
  • 2
  • 3
  • 4
update

可以添加元素,且参数可以是列表,元组,字典等,语法格式如下,x 可以有多个,用逗号分开。

s.update( x )
  • 1

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
移除元素
remove

将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。

s.remove( x )
  • 1

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
discard

如果元素不存在,不会发生错误。格式如下所示:

s.discard( x )
  • 1

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}
  • 1
  • 2
  • 3
  • 4
pop:随机删除

设置随机删除集合中的一个元素,语法格式如下:

s.pop() 
  • 1

使用

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
'''
Runoob
'''
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除。

计算集合元素个数

语法格式如下:计算集合 s 元素个数

len(s)
  • 1

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

  • 1
  • 2
  • 3
  • 4
清空集合

语法格式如下:清空集合 s。

s.clear()
  • 1

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()
  • 1
  • 2
  • 3
  • 4
判断元素是否在集合中存在

语法格式如下:判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False

x in s
  • 1

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
  • 1
  • 2
  • 3
  • 4
  • 5
其他方法

在这里插入图片描述

6、Dictionary(字典)

字典是另一种可变容器模型,且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {} 中 ,格式如下所示:dict 作为 Python 的关键字和内置函数,变量名不建议命名为 dict。

d = {key1 : value1, key2 : value2, key3 : value3 }
  • 1

键必须是唯一的,但值则不必。

值可以取任何数据类型,但键必须是不可变的,如字符串,数字

# 使用大括号 {} 来创建空字典
emptyDict = {}
'''
使用内建函数 dict() 创建字典:
emptyDict = dict()
''' 
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:", len(emptyDict))
# 查看类型
print(type(emptyDict))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

输出结果:

{}
Length: 0
<class 'dict'>
  • 1
  • 2
  • 3
访问字典里的值
tinydict = {'Name': '?abc!', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
  • 1
  • 2
  • 3
  • 4

实例输出结果

tinydict['Name']:  ?abc!
tinydict['Age']:  7
  • 1
  • 2

如果用字典里没有的键访问数据,会输出错误如下

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Alice']: ", tinydict['Alice'])
'''
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'
'''
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
修改字典

向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对

tinydict = {'Name': 'abc', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "?abc!"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

实例输出结果

tinydict['Age']:  8
tinydict['School']:  ?abc!
  • 1
  • 2
删除字典元素

能删单一的元素也能清空字典,清空只需一项操作。

显式删除一个字典用del命令,如下实例:

tinydict = {'Name': 'abc', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

实例输出结果:出现异常是因为:用执行 del 操作后字典不再存在

Traceback (most recent call last):
  File "/runoob-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined
  • 1
  • 2
  • 3
  • 4
获取字典内容(get)

dictget("key", 0)方法不要添加default=
正确的使用

d = {'2023-01-20 00:00:00': 123}
print(d.get('2023-01-2 00:00:00', 12))
  • 1
  • 2

如果像下面这样使用,便会报错

d = {'2023-01-20 00:00:00': 123}
print(d.get('2023-01-2 00:00:00', default=12))
  • 1
  • 2

报错结果

Traceback (most recent call last):
  File "xxx.py", line 69, in <module>
    print(d.get('2023-01-2 00:00:00', default=12))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: dict.get() takes no keyword arguments
  • 1
  • 2
  • 3
  • 4
  • 5
特点
  1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住
  2. 键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行
内置函数

在这里插入图片描述

内置方法

在这里插入图片描述

type()函数和isinstance

二者都是:查询变量所指对象类型

type()

a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
  • 1
  • 2

输出

<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
  • 1

isinstance

a = 111
print(isinstance(a, int))
  • 1
  • 2

输出

True
  • 1

区别

type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

class A:
    pass

class B(A):
    pass

print(isinstance(A(), A))
print(type(A()) == A)
print(isinstance(B(), A))
print(type(B()) == A)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

输出

True
True
True
False
  • 1
  • 2
  • 3
  • 4
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/你好赵伟/article/detail/665749
推荐阅读
相关标签
  

闽ICP备14008679号