python基础Ⅰ（注释、数据类型、运算符、输入输出、流程控制结构、小整数对象池、大整数对象池、range）

我就是我 2022-12-14 12:19 26阅读 0赞

# 一、注释 #

**单行注释**为 **\#**  
**多行注释**为 **‘’’** 或 **“”"**（三个单引号或三个双引号，注意是英文标点），他也**可以赋值给变量，来作为保留格式的字符串使用**  
**特殊注释**：

#!/user/bin/python3 # 指定由哪个解释器来执行脚本（在linux下使用）
    # -*- coding: utf-8 -*- # 设置编码格式（python3默认为utf-8，但python2不是）
    
    print('Hello World!')
    
    message =""" 你好 吗？ """
    print(message)
    # 输出内容为：
    # 你好
    # 吗？
    
    s1 = 'abc'			
    s2 = "abc"
    s3 = '''abc'''
    s4 = """ # s3与s4因为是带有格式的，所以值不相同 abc """
    print(id(s1))			# 1719952853424
    print(id(s2))			# 1719952853424
    print(id(s3))			# 1719952853424
    print(id(s4))			# 1719952896752
    print(s1 == s3)			# True
    print(s1 is s3)			# True
    
    s1 = input()			# 'asd'
    s2 = input()			# 'asd'
    print(s1 == s2)			# True
    print(s1 is s2)			# False

所以**变量赋值**两个变量的地址是**相同的**，而**input输入**两个变量的地址则**不是相同的**

# 二、数据类型 #

**int**、long（Python3取消）、**float**、**complex**（复数）、**bool**（布尔值，True，False）、**str**（字符串）、**dict**（字典）、**tuple**（元组）、**list**（列表）  
要注意的是在Python中，**整数的值不受位数限制**，并且**可以扩展到可用内存的限制**

print(type(10))				# int
    print(type(10.02))			# float
    print(type(True))			# bool
    print(type('nihao'))		# str
    print(type(()))				# tuple
    print(type([]))				# list
    print(type({ }))				# dict

# 三、变量命名规则 #

*  以**字母或下划线开头**，不能以数字开头
 *  **变量区分大小写**
 *  **关键字不能用做变量名**
 *  **要见名识意**，可以小驼峰命名（userName）、大驼峰命名（UserName）、下划线命名（user\_name）
 *  约定：一般变量名全部**大写**就表示为**常量**

# 四、基本操作运算符 #

<table> 
 <thead> 
  <tr> 
   <th>算术运算符</th> 
   <th>操作描述</th> 
   <th>示例(a = 7 , b = 3)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+(加)</td> 
   <td>加</td> 
   <td>a + b = 10</td> 
  </tr> 
  <tr> 
   <td>-(减)</td> 
   <td>减</td> 
   <td>a - b = 4</td> 
  </tr> 
  <tr> 
   <td>*(乘)</td> 
   <td>乘</td> 
   <td>a * b = 21</td> 
  </tr> 
  <tr> 
   <td>/(除)</td> 
   <td>除，保留小数点后面的数</td> 
   <td>a / b = 2.333333</td> 
  </tr> 
  <tr> 
   <td>//(地板除)</td> 
   <td>结果忽略小数点后面的数，只保留整数</td> 
   <td>a // b = 2</td> 
  </tr> 
  <tr> 
   <td>%(取余)</td> 
   <td>余数</td> 
   <td>a % b = 1</td> 
  </tr> 
  <tr> 
   <td>**(指数)</td> 
   <td>左边使底数，右边是指数</td> 
   <td>a ** b = 343</td> 
  </tr> 
  <tr> 
   <td>=</td> 
   <td>赋值</td> 
   <td>把右边赋值给左边</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> 
 </tbody> 
</table>

**要注意的是在使用变量a给变量b赋值的时候，若变量a值在内存池里面已经存在，又因为python为了减少内存浪费，所以变量b会指向变量a的引用，也就是两个变量的引用是一样的**。所以**赋值操作不会开辟新的内存空间，它只是复制了新对象的引用**，且当变量的值为一样时，其地址也为一样

<table> 
 <thead> 
  <tr> 
   <th>比较运算符</th> 
   <th>操作描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>is(等于)</td> 
   <td>等于，比较的是引用而不是值</td> 
  </tr> 
  <tr> 
   <td>==(等于)</td> 
   <td>等于，比较的是值而不是引用</td> 
  </tr> 
  <tr> 
   <td>!=(不等)</td> 
   <td>不等</td> 
  </tr> 
  <tr> 
   <td>&gt;(大于)</td> 
   <td>大于</td> 
  </tr> 
  <tr> 
   <td>&lt;(小于)</td> 
   <td>小于</td> 
  </tr> 
  <tr> 
   <td>&gt;=(大于或等于)</td> 
   <td>大于或等于</td> 
  </tr> 
  <tr> 
   <td>&lt;=(小于或等于)</td> 
   <td>小于或等于</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>逻辑运算符</th> 
   <th>操作描述</th> 
   <th>示例(x,y可为变量或表达式)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>与</td> 
   <td>x and y</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>或</td> 
   <td>x or y</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>非</td> 
   <td>not x</td> 
  </tr> 
 </tbody> 
</table>

注意：**优先级为 () -> not -> and -> or**

print(2>1 and 1<4 or 2<4 and 3<2)		# True

<table> 
 <thead> 
  <tr> 
   <th>位运算符</th> 
   <th>操作描述</th> 
   <th>示例(x,y可为变量或表达式)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>与，全1为1，其他为0</td> 
   <td>x &amp; y</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>或，全0为0，其他为1</td> 
   <td>x | y</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>取反</td> 
   <td>x ~ y</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>异或，相同为0，不同为1。<strong>这个不能表示几次方</strong></td> 
   <td>x ^ y</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移</td> 
   <td>x &lt;&lt; y</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移</td> 
   <td>x &gt;&gt; y</td> 
  </tr> 
 </tbody> 
</table>

注意这里的 **（&，|）和（and，or）是两组比较相似**的运算符，他们**在用法上有些许区别**。  
如下:

print(1 and 0)			# 0，0为False，非0为True
    print(1 or 0)			# 1
    print(1 and 2)			# 2
    print(1 or 2)			# 1
    print(1 & 2)			# 0，位运算，运用二进制计算全1为1，其他为0
    print(1 | 2)			# 3，位运算，运用二进制计算全0为0，其他为1
    print(~5)				# -6，位运算
    print(3 ^ 5)			# 6
    print(16 >> 2)			# 4
    print(16 << 2)			# 64

### 三目运算符 ###

print('真' if 3 > 2 else '假')	# 真

### 优先级 ###

排序(从上到下，从左到右优先级依次降低)：
    **
    ~
    + - (符号运算符)
    * / // %
    + - （加减）
    << >>
    &
    ^
    |
    == != > >= < <=
    is   is not
    not
    and
    or

# 五、输入输出 #

### 输出 ###

> print(value, sep=” “, end=”\\n", file=sys.stdout, flush=False)

**sep为分隔符**，默认为空格；**end为末尾的输出**，默认为\\n

num1 = 2
    print('%2d' % num1)			# 不足2位用空格填充，否则正常显示
    num2 = 2
    print('%02d' % num2)		# 不足2位用0填充，否则正常显示
    num3 = 2.03
    print('%.1f' % num3)		# 保留1位小数，四舍五入，2.0
    id = 200.111111
    print('----%5.2f' % id)		# 从小数点开始先保留2位，然后再加上小数点和整数位一共有5位，若总数超出5位则原样输出，不满5位则用空格补齐，小数点后面有2位，200.11
    print('----%5.10f' % id)	# 从小数点开始先保留10位，然后再加上小数点和整数位一共有5位，若总数超出5位则原样输出，不满5位则用空格补齐，小数点后面有10位，200.1111110000
    print('----%7.2f' % id)		# 从小数点开始先保留2位，然后再加上小数点和整数位一共有7位，若总数超出7位则原样输出，不满7位则用空格补齐，小数点后面有2位， 200.11
    print('----%07.2f' % id)	# 从小数点开始先保留2位，然后再加上小数点和整数位一共有7位，若总数超出7位则原样输出，不满7位则用0补齐，小数点后面有2位，0200.11
    
    name = 'Mike'
    className = 'grade 1'
    print('我是%s'%name)
    print('我是%s，来自%s'%(name, className))	
    
    # 另一种方式format
    print('我是{}'.format(name))
    print('我是{}，来自{}'.format(name, className))		# 我是Mike，来自grade 1
    print('我是{1}，来自{0}'.format(name, className))		# 我是grade 1，来自Mike，其花括号内的值与format函数里面的值一一对应
    
    print(r'我是\t你')			# 这里的r（raw）代表原样输出内容，即使有转义字符也不转义
    
    # print自带换行效果
    # 但如果需要在输出内容中换行时用/n

<table> 
 <thead> 
  <tr> 
   <th>格式符号</th> 
   <th>转换</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>%c</td> 
   <td>字符</td> 
  </tr> 
  <tr> 
   <td>%s</td> 
   <td>字符串，执行时有默认的类型转换str()</td> 
  </tr> 
  <tr> 
   <td>%i</td> 
   <td>有符号的十进制整数</td> 
  </tr> 
  <tr> 
   <td>%d</td> 
   <td>有符号的十进制整数</td> 
  </tr> 
  <tr> 
   <td>%u</td> 
   <td>无符号的十进制整数</td> 
  </tr> 
  <tr> 
   <td>%o</td> 
   <td>八进制整数</td> 
  </tr> 
  <tr> 
   <td>%x</td> 
   <td>十六进制整数（小写字母）</td> 
  </tr> 
  <tr> 
   <td>%e</td> 
   <td>索引符号（小写’e’）</td> 
  </tr> 
  <tr> 
   <td>%E</td> 
   <td>索引符号（大写’E’）</td> 
  </tr> 
  <tr> 
   <td>%f</td> 
   <td>浮点实数</td> 
  </tr> 
  <tr> 
   <td>%g</td> 
   <td>%f和%e的简写</td> 
  </tr> 
  <tr> 
   <td>%G</td> 
   <td>%f和%E的简写</td> 
  </tr> 
 </tbody> 
</table>

### 输入 ###

input可用于输入，不过输入的结果**都是str类型**的，如果**接收其他类型则需要进行相应的转换**

name = input('请输入您的姓名：')
    print('输入的姓名为：{}'.format(name))		# 输入的姓名为：li
    
    age = input('请输入您的年龄：')
    print('输入的年龄为：{}'.format(age))			# 输入的年龄为：13
    print(type(age))							# <class 'str'>
    print(type(int(age)))						# <class 'int'>，强制转换
    print(type(float(age)))						# <class 'float'>，强制转换
    print(float(age))							# 13.0，小数点后一位

# 六、流程控制结构 #

### if-else ###

不过要记住**python里面没有switch**语句

import random						# 引入随机数模块
    
    score = random.randint(0, 100)		# 随机整数，包括0，100
    if score >= 90:
        print('Your level is A')
        pass
    elif score >= 80:
        print('Your level is B')
        pass
    elif score >= 70:
        print('Your level is C')
        pass
    elif score >= 60:
        print('Your level is D')
        pass
    else:
        print('Your level is E')
        pass

### while ###

适合于**未知循环次数**，**块**里面可以**申请变量**，且申请的变量为**全局变量**

x = 1			# 九九乘法表
    while x <= 9:
        y = x
        while y <= 9:
            print('%d*%d=%02d' % (y, x, x * y), end=' ')	# 这里的end为print结束的内容，默认为\n
            y += 1
            pass
        print()		# 空输出，打印出\n
        x += 1
        pass
    
    
    currentRow = 1			# 打印等边三角形
    totalRow = 5
    while currentRow <= totalRow:		# 打印行数
        currentColSpace = 1
        while currentColSpace <= totalRow - currentRow:	# 打印空格
            print(' ', end='')
            currentColSpace += 1
            pass
        currentColContent = 1
        while currentColContent <= 2 * currentRow - 1: # 打印内容
            print('*', end='')
            currentColContent += 1
            pass
        print()
        currentRow += 1
        pass

### for ###

适合于**已知循环次数**，**块**里面可以**申请变量**，且申请的变量为**全局变量**

content = 'Hello there!'		# 字符串本身就是一个字符类型的集合
    for value in content:
        print(value)
        pass
    
    for value1 in range(1, 10):		# 九九乘法表
        for value2 in range(1, value1 + 1):
            print('%d*%d=%2d' % (value1, value2, value2 * value1), end=' ')
            pass
        print()
        pass

### break ###

满足本次条件时，**跳出该块，只能在循环体内使用break，python里面没有switch**

### continue ###

满足本次条件时，**跳出本次，继续下次操作，仅结束本次循环**

### for……else ###

for item in range(3):				# 循环三次
        inputU = input('请输入用户名：')
        inputP = input('请输入密码：')
        if inputU == username and inputP == password:
            print('你已成功登入')
            break			# 账号密码正确则退出当前循环，不执行最下面的else
            pass
        else:
            print('你的账号或密码错误')
        pass
    else:				# 只有当for循环正常完成时才执行
        print('你的账号已被锁定...')
        pass

### while……else ###

index = 1
    
    while index <= 10:
        print(index)
        if index == 6:
            break
            pass
        index += 1
        pass
    else:			# 只有当while循环正常完成时才执行
        print('该else执行了吗')
        pass

# 七、其他 #

### python的文件执行与命令行执行结果不一致原因 ###

**python的文件在执行的时候，会创建一个大对象池**，用于存储文件在执行过程中所有产生的变量；**命令行执行时因为命令是一行输入一行输出的**，且因为有**小整数池与大整数池**的存在导致了他们两个在一些情况下执行的结果不同  
如：

foo = 'hello world'
    bar = 'hello world'		# pycharm里执行 命令行执行
    print(id(foo))			# 2002413383088 2655828823728
    print(id(bar))			# 2002413383088 2655828845872
    print(foo == bar)		# True True
    print(foo is bar)		# True False

### 小整数对象池 ###

整数在程序中的使用非常广泛，Python为了优化速度，使用了**小整数对象池， 避免为整数频繁申请和销毁内存空间**。Python 对**小整数的定义是 \[-5, 256\]** 这些整数对象**被创建好后就在同一个对象池内**，**不会被垃圾回收**。而对字符的处理机制为**字符串长度小于等于20**且**没有被空格分隔**，则**不用多次创建**，若**有空格或长度大于20则创建多次**  
如：

a=-5
    b=-5				# pycharm里执行 命令行执行
    print(a is b)		# True True
    
    a=256
    b=256
    print(a is b)		# True True
    
    a=1000
    b=1000
    print(a is b)		# True False
    
    a="helloworld"
    b="helloworld"
    print(a is b)		# True True
    
    a="hello world"
    b="hello world"
    print(a is b)		# True False
    
    s1 = "a" * 20
    s2 = "a" * 20
    print(s1 is s2)		# True True
    
    s1 = "a" * 21
    s2 = "a" * 21
    print(s1 is s2)		# True False

### 大整数对象池 ###

**终端是每次执行一次，所以每次的大整数都重新创建（而文件执行则不用）**，而**在pycharm中，每次运行是所有代码都加载都内存中，属于一个整体，在同一个对象池内**。

a=1000
    b=1000				# pycharm里执行 命令行执行
    print(a is b)		# True False
    
    a=-1888
    b=-1888
    print(a is b)		# True False

### range(start, stop\[, step\]) ###

*  **start**: 计数从 start 开始。**默认是从 0 开始**。例如range（5）等价于range（0， 5）;
 *  **stop**: 计数到 stop 结束，**但不包括 stop**。例如：range（0， 5） 是\[0, 1, 2, 3, 4\]没有5
 *  **step**：步长，**默认为1**。例如：range（0， 5） 等价于 range(0, 5, 1)

>>> type(range(1, 0))
    <class 'range'>

### 切片 ###

*  要注意的是**前两个值的顺序**要和**第三个值的正负号一致**。（正号则从左到右，负号则相反）。
 *  执行顺序为先两个，在后一个

本文只用于个人学习与记录