Python基础详细笔记(一)：基础语法

桃扇骨 2023-09-29 15:03 34阅读 0赞

##  ##

**目录**

[Python基础详细笔记(一)：基础语法][Python]

1.1 标识符

1.2 保留字

1.3 编码

1.4 注释

1.5 缩进

1.6 多行

1.7 输出print()

1.8 输入input

1.9 变量

1.10 数值类型

1.11数值类型

1.11 运算符

[Python基础详细笔记(二)：流程语句][Python 1]

[Python基础详细笔记(三)：字符串str][Python_str]

[Python基础详细笔记(四)：列表list][Python_list]

[Python基础详细笔记(五)：元组tuple][Python_tuple]

[Python基础详细笔记(六)：字典dict][Python_dict]

--------------------

## 1.1 标识符 ##

**1、含义**

简单的说标识符就是变量、函数、类、模块和其他对象的名称。

**2、命名规则**

*  Python 中标识符由字母、汉族、数字、下划线( \_ )组成；
 *  这 4 类字符之外的其他字符，肯定是不合法标识符；
 *  不能以数字开头，不能是python关键词，字母区分大小写；
 *  标识符可以是汉字。但我们应尽量避免使用汉字作为标识符，这会避免遇到很多没必要的错误

**【扩展知识】**

**3、命名的规范用法**

在不同对象的命名也是有一定规范

*  函数名、类中属性名、类中的方法名：全部使用小写字母
 *  常量名：全部使用大写字母
 *  类名：单词首字母大写
 *  包名：应尽量简短，全部使用小写字母
 *  模块名：应尽量简短，全部使用小写字母

遇到多个单词可用下划线分开

**4、 保留的标识符类**

一些标识符类具有特殊的含义，以下划线字符开头和结尾（\*为名称）

*  **\_\*：**表示不能直接访问的类属性。
 *  **\_ \_\*\_ \_：**系统定义的名称，是专用标识符。这些名称由解释器及其实现 (包括标准库) 所定义
 *  **\_ \_\*：**类的私有名称。

## 1.2 保留字 ##

保留字即**关键字**，我们不能把它们用作任何标识符名称。

Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

import keyword
    N=keyword.kwlist
    print(N)
    #输出
    '''
    ['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']
    '''

<table> 
 <thead> 
  <tr> 
   <th>and</th> 
   <th>exec</th> 
   <th>not</th> 
   <th>assert</th> 
   <th>finally</th> 
   <th>or</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>break</strong></td> 
   <td><strong>for</strong></td> 
   <td><strong>pass</strong></td> 
   <td><strong>class</strong></td> 
   <td><strong>from</strong></td> 
   <td><strong>print</strong></td> 
  </tr> 
  <tr> 
   <td><strong>continue</strong></td> 
   <td><strong>global</strong></td> 
   <td><strong>raise</strong></td> 
   <td><strong>def</strong></td> 
   <td><strong>if</strong></td> 
   <td><strong>return</strong></td> 
  </tr> 
  <tr> 
   <td><strong>del</strong></td> 
   <td><strong>import</strong></td> 
   <td><strong>try</strong></td> 
   <td><strong>elif</strong></td> 
   <td><strong>in</strong></td> 
   <td><strong>while</strong></td> 
  </tr> 
  <tr> 
   <td><strong>else</strong></td> 
   <td><strong>is</strong></td> 
   <td><strong>with</strong></td> 
   <td><strong>except</strong></td> 
   <td><strong>lambda</strong></td> 
   <td><strong>yield</strong></td> 
  </tr> 
 </tbody> 
</table>

注：自定义标识符时不能使用关键字。

## 1.3 编码 ##

默认情况下，Python 3x源码文件以 **UTF-8** 编码（可识别中文），所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

Python 中通过在开头加入`# -*- coding: UTF-8 -*-`进行指定。

###  ###

## 1.4 注释 ##

*  单行注释\#开头shift + \#
 *  多行注释可以用多个 \# 号，还有 ''' 和 """：
 *  单行和多行一样的方式：Ctr+ / （前提是选中需要注释的代码）（去掉注释也可）

#单行注释以#开头
    # 第一个注释
    print ("Hello, Python!") # 第二个注释
    
    #多行多行注释可以用多个 # 号，还有 ''' 和 """
    
    # 第一个注释
    # 第二个注释
     
    '''
    第三注释
    第四注释
    '''
     
    """
    第五注释
    第六注释
    """
    print ("Hello, Python!")

## 1.5 缩进 ##

这里需要大家习惯，对与学过其他语言的人来说，初学容易混淆。

*  python最具特色的就是使用缩进来表示代码块，不需要使用大括号 \{\} 。
 *  缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

for i in range(5):
        if i<=2:
            print(i)
        else:
            print("%d大于5的"%i)

##  ##

## 1.6 多行 ##

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \\ 来实现多行语句

total = item_one + \
            item_two + \
            item_three

在 \[\], \{\}, 或 () 中的多行语句，不需要使用反斜杠 \\

total = ['item_one', 'item_two', 'item_three',
            'item_four', 'item_five']

###  ###

## 1.7 输出print() ##

Python 输出使用 print()，内容加在括号中即可。

print('Hello Python')

**【扩展知识】**

*   **格式化% 方式**

age = 5
    name = "猿同学"
    print("我的年龄是%d岁" % age)
    print("我的名字是%s" % name)
    print("我的年龄是%d岁，我的名字是%s" % (age, name))

格式化输出

<table> 
 <thead> 
  <tr> 
   <th>字符</th> 
   <th>含有</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>%s</td> 
   <td>字符串</td> 
  </tr> 
  <tr> 
   <td>%d</td> 
   <td>有符号十进制整数，%06d表示输出的整数显示位数字，不足的地方使用0补全</td> 
  </tr> 
  <tr> 
   <td>%f</td> 
   <td>浮点数，%.02f表示小数点后只显示两位</td> 
  </tr> 
  <tr> 
   <td>%%</td> 
   <td>输出%</td> 
  </tr> 
 </tbody> 
</table>

*  **format 函数**

str = "我的名字是{}，我的国籍是{}".format("猿同学", "中国")
    print(str)

索引填充

# 索引填充
    str = "{0},{1},{0}!".format("你好","粉丝们")
    print(str)

*  **关键字填充**

str = "姓名：{name}，年龄：{age}".format(name = "猿同学", age = 5)
    print(str)

*   **通过字典设置参数， 用 \*\* 展开map集合**

info = {"name":"猿同学", "age":5}
    str = "姓名：{name}，年龄：{age}".format(**info)
    print(str)

*  **利用列表的索引设置参数**

list = ["菜鸟教程", "https://www.runoob.com"]
    str = "网站名称：{0[0]}\n网址：{0[1]}\n时间：{1}".format(list, 2022)
    # 第一个0表示format里的元素，第二个0表示list的索引
    print(str)

*  **F-strings**

name = "猿同学"
    age = 5
    print(F"你好好，我是{name}今年{age}岁了") # f可以是大写也可以是小写
    
    #也可以是多行的
    teacher = "猿老师"
    days = 3
    message = (
        f"{'请假条':_^15}\n"
        f"{teacher}您好：\n"
        f"我想请假{days}天，可以吗？"
    )
    print(message)

*  **任意表达式**

print(f"{2 * 100}")
    print(f"{'abc'.upper()}")

*  **数字处理输出**

print("圆周率：{:.2f}".format(3.1415926)) # :表示对format的内容就行操作，.2f表示保留两位小数
    print("{:,}".format(100000000))  # 千分位加逗号，格式化
    print("{:.2e}".format(100000000))  # 科学计数法, .2表示保留小数点后面两位
    print("{:.1%}".format(0.25))  # 百分号表示， .1表示保留一位小数

str = "欢迎来到我的博客"
    print(f"{str:->15}")
    print(f"{str:-<15}")
    print(f"{str:-^15}")

###  ###

## **1.8 输入input** ##

Python 提供了一个 input()，可以让用户输入字符串，并存放到一个变量里。

name = input("请输入你的名字：")
    print('你好！',name)

**【扩展知识】**

*  **单个输入**

#单个输入
    n = input() #无参数 默认返回字符串
    n = input("有提示参数的输入") #有提示性输入语句的输入，仍是以str类型返回
    n = int(input())   #根据给定的类型输入，返回值类型int
    n = float(input()) #根据给定的类型输入，返回值类型float
    n = eval(input())  #eval()函数用来执行一个字符串表达式，并返回表达式的值。也可以用于返回数据本身的类型

*  **多个输入**

a, b = input().split(" ") # 输入字符串(默认返回类型)a 和 b  以(空格)分隔
    a, b, c = eval(input())   #输入三个值(任何类型)中间由逗号分隔
    a, b, c = int(input())    #输入三个值(int)中间由逗号分隔
    '''
    eg:输入:123,'test',1.50
    a:123
    b:'test'
    c:1.50
    '''
    a, b, c = map(eval, input().split(" ")) #输入三个值(任何类型)中间(空格)分隔
    a, b, c = map(int, input().split(" "))  #输入三个值(int)中间(空格)分隔

*  **一行输入**

# 方法1.
    lst = list(map(int, input().split(" ")))  # 输入一行值(int)由(空格)分隔 存入列表
    
    # 方法2. 输入n个数
    n = int(input())
    s = input()  # 将数一行输入 空格分隔
    lst = []
    for i in s.split(" "):
        lst.append(int(i))
    
    # 两种输出方式
    for i in lst:
        print(i, end=" ")
    for i in range(n):
        print(lst[i], end=" ")

## 1.9 变量 ##

**语法：**

`变量名 = 数据`

**变量名：** 程序员自己命名

*  要求：
    
    1.  标识符。
    2.  不能是关键字。
 *  规范：
    
    1.  见名知义 。
    2.  满足`PEP8`的命名规范。*（所有字母都小写，所有单词之间用下划线隔开）*
    3.  不使用系统提供的类型名、函数名和模块名。
 *  **变量中保存的数据能做什么，变量就能做什么。**

# 2、变量的使用
    
    name = '猿同学'
    print('姓名：', name)  # 姓名： 猿同学
    
    num1 = 3
    num2 = 4
    print('和为：', num1 + num2)  # 和为： 7
    
    age = 2
    print('年龄为：', age + 3)  # 年龄为： 5
    
    #字符串（可迭代对象）
    print('abc'[0])  # a
    str1 = 'abc'
    print(str1[1])  # b

*  **修改变量中的数据（重新给变量赋值）**

# 重新给变量赋值
    
    name = '猿同学'
    print(name) # 猿同学
    # 重新赋值
    name = '猿老师'
    print(name) # 猿老师
    # 再次赋值（同一变量可以保存不同类型的值）
    name = True  # (布尔类型）
    print(name) # True

注意：python中同一变量可以保存不同类型的值。

*  **同时给多个变量赋值**

# 给多个变量同时赋不同的值
    
    a, b, c = 1, 2, 3
    print(a, b, c)  # 1 2 3
    
    # 给不同的变量赋相同的值
    c1 = c2 = c3 = 33
    print(c1, c2, c3)  # 33 33 33

*  **交换两个变量的值**
 *      # 交换两个变量的值
        x = 1
        y = 2
        print('x：{},y：{}'.format(x, y))  # x：1,y：2
        x, y = y, x
        print('x：{},y：{}'.format(x, y))  # x：2,y：1
        
        # 交换三个变量的值
        x1 = 1
        x2 = 2
        x3 = 3
        
        x1, x2, x3 = x3, x1, x2
        print(x1, x2, x3) # 3 1 2
 *  ##  ##

## 1.10 数据类型 ##

Python3 中有六个标准的数据类型：

*  number（数字）
 *  string（[字符串][Link 1]）
 *  tuple（[元组][Link 2]）
 *  list（列表）
 *  set（集合）
 *  dictionary（字典）

Python3 的六个标准数据类型中：

**不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）。

**可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。

这六个数据类型将会在后续一一介绍。

##  ##

## **1.11数值类型** ##

*  **数字类型**

**int（整型）**

在32位机器上，整数的位数是32位，取值范围是-231~231-1，即-2147483648~214748364；在64位系统上，整数的位数为64位，取值范围为-263~263-1，即9223372036854775808~9223372036854775807。

**long（长整型）**

Python长整型没有指定位宽，但是由于机器内存有限，使用长的长整数数值也不可能无限大。

**float（浮点型）**

浮点型也就是带有小数点的数，其精度和机器有关。

**complex（复数）**

Python还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

*  **字符串**

在Python中，加了引号的字符都被认为是字符串，其声明有三种方式，分别是：单引号、双引号和三引号；Python中的字符串有两种数据类型，分别是str类型和unicode类型，str类型采用的ASCII编码，无法表示中文，unicode类型采用unicode编码，能够表示任意字符，包括中文和其他语言。

*  **布尔型**

和其他编程语言一样，Python布尔类型也是用于逻辑运算，有两个值：True（真）和False（假）。

*  **列表**

列表是Python中使用最频繁的数据类型，集合中可以放任何数据类型，可对集合进行创建、查找、切片、增加、修改、删除、循环和排序操作。

*  **元组**

元组和列表一样，也是一种序列，与列表不同的是，元组是不可修改的，元组用”()”标识，内部元素用逗号隔开。

*  **字典**

字典是一种键值对的集合，是除列表以外Python之中最灵活的内置数据结构类型，列表是有序的对象集合，字典是无序的对象集合。

*  **集合**

集合是一个无序的、不重复的数据组合，它的主要作用有两个，分别是去重和关系测试。

**数据类型转换**

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

<table> 
 <tbody> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-int.html" title="int(x [,base])" rel="nofollow">int(x [,base])</a></p> </td> 
   <td> <p>将x转换为一个整数</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-float.html" title="float(x)" rel="nofollow">float(x)</a></p> </td> 
   <td> <p>将x转换到一个浮点数</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-complex.html" title="complex(real [,imag])" rel="nofollow">complex(real [,imag])</a></p> </td> 
   <td> <p>创建一个复数</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-str.html" title="str(x)" rel="nofollow">str(x)</a></p> </td> 
   <td> <p>将对象 x 转换为字符串</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-repr.html" title="repr(x)" rel="nofollow">repr(x)</a></p> </td> 
   <td> <p>将对象 x 转换为表达式字符串</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-eval.html" title="eval(str)" rel="nofollow">eval(str)</a></p> </td> 
   <td> <p>用来计算在字符串中的有效Python表达式,并返回一个对象</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python3-func-tuple.html" title="tuple(s)" rel="nofollow">tuple(s)</a></p> </td> 
   <td> <p>将序列 s 转换为一个元组</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python3-att-list-list.html" title="list(s)" rel="nofollow">list(s)</a></p> </td> 
   <td> <p>将序列 s 转换为一个列表</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-set.html" title="set(s)" rel="nofollow">set(s)</a></p> </td> 
   <td> <p>转换为可变集合</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-dict.html" title="dict(d)" rel="nofollow">dict(d)</a></p> </td> 
   <td> <p>创建一个字典。d 必须是一个 (key, value)元组序列。</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-frozenset.html" title="frozenset(s)" rel="nofollow">frozenset(s)</a></p> </td> 
   <td> <p>转换为不可变集合</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-chr.html" title="chr(x)" rel="nofollow">chr(x)</a></p> </td> 
   <td> <p>将一个整数转换为一个字符</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-ord.html" title="ord(x)" rel="nofollow">ord(x)</a></p> </td> 
   <td> <p>将一个字符转换为它的整数值</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-hex.html" title="hex(x)" rel="nofollow">hex(x)</a></p> </td> 
   <td> <p>将一个整数转换为一个十六进制字符串</p> </td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://www.runoob.com/python3/python-func-oct.html" title="oct(x)" rel="nofollow">oct(x)</a></p> </td> 
   <td> <p>将一个整数转换为一个八进制字符串</p> </td> 
  </tr> 
 </tbody> 
</table>

###  ###

## 1.11 运算符 ##

以下假设变量 a=10，变量 b=21：

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>加 - 两个对象相加</td> 
   <td>a + b 输出结果 31</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减 - 得到负数或是一个数减去另一个数</td> 
   <td>a - b 输出结果 -11</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘 - 两个数相乘或是返回一个被重复若干次的字符串</td> 
   <td>a * b 输出结果 210</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除 - x 除以 y</td> 
   <td>b / a 输出结果 2.1</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取模 - 返回除法的余数</td> 
   <td>b % a 输出结果 1</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>幂 - 返回x的y次幂</td> 
   <td>a**b 为10的21次方</td> 
  </tr> 
  <tr> 
   <td>//</td> 
   <td>取整除 - 向下取接近商的整数</td> 
   <td> <pre>&gt;&gt;&gt; 9//2
4
&gt;&gt;&gt; -9//2
-5</pre> </td> 
  </tr> 
 </tbody> 
</table>

*  **Python比较运算符**

以下假设变量a为10，变量b为20：

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>等于 - 比较对象是否相等</td> 
   <td>(a == b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于 - 比较两个对象是否不相等</td> 
   <td>(a != b) 返回 True。</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>大于 - 返回x是否大于y</td> 
   <td>(a &gt; b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。</td> 
   <td>(a &lt; b) 返回 True。</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于 - 返回x是否大于等于y。</td> 
   <td>(a &gt;= b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于 - 返回x是否小于等于y。</td> 
   <td>(a &lt;= b) 返回 True。</td> 
  </tr> 
 </tbody> 
</table>

*  **Python赋值运算符**

以下假设变量a为10，变量b为20：

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>=</td> 
   <td>简单的赋值运算符</td> 
   <td>c = a + b 将 a + b 的运算结果赋值为 c</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>加法赋值运算符</td> 
   <td>c += a 等效于 c = c + a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法赋值运算符</td> 
   <td>c -= a 等效于 c = c - a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘法赋值运算符</td> 
   <td>c *= a 等效于 c = c * a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法赋值运算符</td> 
   <td>c /= a 等效于 c = c / a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取模赋值运算符</td> 
   <td>c %= a 等效于 c = c % a</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂赋值运算符</td> 
   <td>c **= a 等效于 c = c ** a</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>取整除赋值运算符</td> 
   <td>c //= a 等效于 c = c // a</td> 
  </tr> 
  <tr> 
   <td>:=</td> 
   <td>海象运算符，可在表达式内部为变量赋值。<strong>Python3.8 版本新增运算符</strong>。</td> 
   <td> <p>在这个示例中，赋值表达式可以避免调用 len() 两次:</p> <pre>if (n := len(a)) &gt; 10:
    print(f"List is too long ({n} elements, expected &lt;= 10)")</pre> </td> 
  </tr> 
 </tbody> 
</table>

*  **Python位运算符**

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0</td> 
   <td>(a &amp; b) 输出结果 12 ，二进制解释： 0000 1100</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。</td> 
   <td>(a | b) 输出结果 61 ，二进制解释： 0011 1101</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>按位异或运算符：当两对应的二进位相异时，结果为1</td> 
   <td>(a ^ b) 输出结果 49 ，二进制解释： 0011 0001</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于&nbsp;-x-1</td> 
   <td>(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移动运算符：运算数的各二进位全部左移若干位，由"&lt;&lt;"右边的数指定移动的位数，高位丢弃，低位补0。</td> 
   <td>a &lt;&lt; 2 输出结果 240 ，二进制解释： 1111 0000</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移动运算符：把"&gt;&gt;"左边的运算数的各二进位全部右移若干位，"&gt;&gt;"右边的数指定移动的位数</td> 
   <td>a &gt;&gt; 2 输出结果 15 ，二进</td> 
  </tr> 
 </tbody> 
</table>

*  **Python逻辑运算符**

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>逻辑表达式</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>and</td> 
   <td>x and y</td> 
   <td>布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。</td> 
   <td>(a and b) 返回 20。</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>x or y</td> 
   <td>布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。</td> 
   <td>(a or b) 返回 10。</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>not x</td> 
   <td>布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。</td> 
   <td>not(a and b) 返回 False</td> 
  </tr> 
 </tbody> 
</table>

*  **Python成员运算符**

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>in</td> 
   <td>如果在指定的序列中找到值返回 True，否则返回 False。</td> 
   <td>x 在 y 序列中 , 如果 x 在 y 序列中返回 True。</td> 
  </tr> 
  <tr> 
   <td>not in</td> 
   <td>如果在指定的序列中没有找到值返回 True，否则返回 False。</td> 
   <td>x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。</td> 
  </tr> 
 </tbody> 
</table>

*  Python身份运算符

身份运算符用于比较两个对象的存储单元

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>is</td> 
   <td>is 是判断两个标识符是不是引用自一个对象</td> 
   <td><strong>x is y</strong>, 类似&nbsp;<strong>id(x) == id(y)</strong>&nbsp;, 如果引用的是同一个对象则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>is not</td> 
   <td>is not 是判断两个标识符是不是引用自不同对象</td> 
   <td><strong>x is not y</strong>&nbsp;， 类似&nbsp;<strong>id(x) != id(y)</strong>。如果引用的不是同一个对象则返回结果 True，否则返回 False。</td> 
  </tr> 
 </tbody> 
</table>

注： [id()][id] 函数用于获取对象内存地址。

###  ###

*  **Python运算符优先级**

以下表格列出了从最高到最低优先级的所有运算符：

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>指数 (最高优先级)</td> 
  </tr> 
  <tr> 
   <td>~ + -</td> 
   <td>按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)</td> 
  </tr> 
  <tr> 
   <td>* / % //</td> 
   <td>乘，除，求余数和取整除</td> 
  </tr> 
  <tr> 
   <td>+ -</td> 
   <td>加法减法</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt; &lt;&lt;</td> 
   <td>右移，左移运算符</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>位 'AND'</td> 
  </tr> 
  <tr> 
   <td>^ |</td> 
   <td>位运算符</td> 
  </tr> 
  <tr> 
   <td>&lt;= &lt; &gt; &gt;=</td> 
   <td>比较运算符</td> 
  </tr> 
  <tr> 
   <td>== !=</td> 
   <td>等于运算符</td> 
  </tr> 
  <tr> 
   <td>= %= /= //= -= += *= **=</td> 
   <td>赋值运算符</td> 
  </tr> 
  <tr> 
   <td>is is not</td> 
   <td>身份运算符</td> 
  </tr> 
  <tr> 
   <td>in not in</td> 
   <td>成员运算符</td> 
  </tr> 
  <tr> 
   <td>not and or</td> 
   <td>逻辑运算符</td> 
  </tr> 
 </tbody> 
</table>

###  ###

[Python]: https://blog.csdn.net/qq_21402983/article/details/124851579
[Python 1]: https://blog.csdn.net/qq_21402983/article/details/124868275
[Python_str]: https://blog.csdn.net/qq_21402983/article/details/124874343
[Python_list]: https://blog.csdn.net/qq_21402983/article/details/124910598
[Python_tuple]: https://blog.csdn.net/qq_21402983/article/details/124925215
[Python_dict]: https://blog.csdn.net/qq_21402983/article/details/124933849
[Link 1]: https://so.csdn.net/so/search?q=%E5%AD%97%E7%AC%A6%E4%B8%B2&spm=1001.2101.3001.7020
[Link 2]: https://so.csdn.net/so/search?q=%E5%85%83%E7%BB%84&spm=1001.2101.3001.7020
[id]: https://www.runoob.com/python/python-func-id.html