python3：基础语法、及6种基本数据类型、找到字典的下标 index、获取list中指定元素的位置索引_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）

dict的get("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