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

不念不忘少年蓝@ 2024-03-27 09:29 63阅读 0赞

## 基础语法 ##

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

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

### 标识符 ###

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

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

标识符`对大小写敏感`。

### 注释 ###

# 第一个注释
    # 第二个注释
    
    '''
    第三注释
    第四注释
    '''
    
    
    """
    第五注释
    第六注释
    """
    print("Hello, Python!")

### 行与缩进 ###

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

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

if True:
        print("Answer")
        print("True")
    else:
        print("Answer")
     print("False")  # 缩进不一致，会导致运行错误

### 空行 ###

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

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

### print 输出 ###

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

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

# 换行输出
    print(x)
    print(y)
    
    print('---------')
    # 不换行输出
    print(x, end=" ")
    print(y, end=" ")
    print("xxx")

输出

a
    b
    ---------
    a b xxx

其还支持参数格式化，与 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)  # 显示正负号

输出

the length of (?ABC!) is 5
         3.142
    pi = 3.142
    000003.142
    3.142     
    +3.141593

python字符串格式化符号:  
![在这里插入图片描述][3048eef0384a42e9813625208f726e1b.png]

### 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'))

### 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
    1
    1
    =========
    1
    2
    runoob

### 不可变数据（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))

输出

True
    True
    True
    2
    1
    1
    0

#### 2、String（字符串） ####

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

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

字符串的截取的语法格式

变量[头下标:尾下标]

`索引值以 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')  # 不换行

输出

123456
    12345
    1
    345
    3456
    123456123456
    123456TEST
    123
    456
    123\n456

#### 3、Tuple（元组） ####

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

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

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

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

输出

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

tup1 = (50)
    print(type(tup1))
    
    tup2 = (50,)
    print(type(tup2))

输出

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

![在这里插入图片描述][80253dac50ac4c2a8349d32a927b543e.png]

##### 访问修改删除元组 #####

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

`元组中的元素值是不允许删除的，但我们可以使用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)

输出

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'?

### 可变数据（3 个） ###

#### 4、List（列表） ####

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

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

`与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。`  
![在这里插入图片描述][98e4b560472d404bafa8ed76cb33d928.png]

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

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

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

##### 访问更新删除列表 #####

###### 访问 ######

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
    print(list[0])
    print(list[-2])
    print(list[0:4])
    print(list[1:-2])

输出

red
    white
    ['red', 'green', 'blue', 'yellow']
    ['green', 'blue', 'yellow']

###### 更新 ######

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
    list[0] = 1
    print(list)
    list.append(7)
    print(list)

输出

[1, 'green', 'blue', 'yellow', 'white', 'black']
    [1, 'green', 'blue', 'yellow', 'white', 'black', 7]

###### 删除 ######

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
    del list[0]
    print(list)

输出

['green', 'blue', 'yellow', 'white', 'black']

###### 比较 ######

`列表比较需要引入 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))

输出

operator.eq(a,b):  False
    operator.eq(c,b):  True

###### 其他 ######

![在这里插入图片描述][cae528846b6b4e788a2dd753eb233e51.png]

#### 5、Set（集合） ####

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

##### 创建格式 #####

parame = {
        value01,value02,...}
    # 或者
    set(value)

>>> 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'}

##### 添加元素 #####

###### add ######

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

s.add( x )

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
    >>> thisset.add("Facebook")
    >>> print(thisset)
    {
        'Taobao', 'Facebook', 'Google', 'Runoob'}

###### update ######

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

s.update( x )

使用

>>> 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'}

##### 移除元素 #####

###### remove ######

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

s.remove( x )

使用

>>> 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'

###### discard ######

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

s.discard( x )

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
    >>> thisset.discard("Facebook")  # 不存在不会发生错误
    >>> print(thisset)
    {
        'Taobao', 'Google', 'Runoob'}

###### pop：随机删除 ######

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

s.pop()

使用

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
    x = thisset.pop()
    print(x)
    '''
    Runoob
    '''

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

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

##### 计算集合元素个数 #####

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

len(s)

使用

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

##### 清空集合 #####

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

s.clear()

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
    >>> thisset.clear()
    >>> print(thisset)
    set()

##### 判断元素是否在集合中存在 #####

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

x in s

使用

>>> thisset = set(("Google", "Runoob", "Taobao"))
    >>> "Runoob" in thisset
    True
    >>> "Facebook" in thisset
    False

##### 其他方法 #####

![在这里插入图片描述][bf1171736fee46a48151eda2e7995899.png]

#### 6、Dictionary（字典） ####

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

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

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

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

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

# 使用大括号 {} 来创建空字典
    emptyDict = {
        }
    '''
    使用内建函数 dict() 创建字典：
    emptyDict = dict()
    ''' 
    # 打印字典
    print(emptyDict)
    # 查看字典的数量
    print("Length:", len(emptyDict))
    # 查看类型
    print(type(emptyDict))

输出结果：

{}
    Length: 0
    <class 'dict'>

##### 访问字典里的值 #####

tinydict = {
        'Name': '?abc!', 'Age': 7, 'Class': 'First'}
     
    print ("tinydict['Name']: ", tinydict['Name'])
    print ("tinydict['Age']: ", tinydict['Age'])

实例输出结果

tinydict['Name']:  ?abc!
    tinydict['Age']:  7

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

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'
    '''

##### 修改字典 #####

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

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

实例输出结果

tinydict['Age']:  8
    tinydict['School']:  ?abc!

##### 删除字典元素 #####

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

显式删除一个字典用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'])

实例输出结果：出现异常是因为：**用执行 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

##### 获取字典内容（get） #####

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

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

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

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

报错结果

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.  `键必须不可变`，所以可以用数字，字符串或元组充当，而用列表就不行

##### 内置函数 #####

![在这里插入图片描述][17f19cc81b494681a706ac8d57c35f77.png]

##### 内置方法 #####

![在这里插入图片描述][bed361a6bc6848a38ee1cba4347f0a5b.png]

### type()函数和isinstance ###

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

#### type() ####

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

输出

#### isinstance ####

a = 111
    print(isinstance(a, int))

输出

True

#### 区别 ####

`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)

输出

True
    True
    True
    False

[3048eef0384a42e9813625208f726e1b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c59d21dea4984f4f805976b6a550de5f.png
[80253dac50ac4c2a8349d32a927b543e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/94039e562d784e689d30923858d315e4.png
[98e4b560472d404bafa8ed76cb33d928.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5f30fd7fa57642f9915b096dc1c42571.png
[eec3fe4d8ea943a181cdb2a7e9d1dea8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d5cd51225aee4da28f674c58083d47ed.png
[35e729e8319040d88ea116331bea179d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5b7dfab706bb47419955158f77509efc.png
[cae528846b6b4e788a2dd753eb233e51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/da1bf39301624e958b1ef5713de34c1f.png
[bf1171736fee46a48151eda2e7995899.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/53e3226fc4bf4cafb639ddd8334383e9.png
[17f19cc81b494681a706ac8d57c35f77.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/88c5db0856e2491b825efd068cc2d6d4.png
[bed361a6bc6848a38ee1cba4347f0a5b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/80c0014e1aaf432fb8a8f6828cb15707.png