Python是当今世界最流行的程序语言之一。由荷兰人，吉多·范罗苏姆（Guido van Rossum）1989年发明，1991年公布。

一、关闭交互模式

  1.  Ctrl+Z和回车
  2. 输入quit()或exit()命令
  3. 直接关闭命令行窗口

二、程序基本格式

  • 用缩进而不是{}表示程序块的层次关系
  • 每行注释前加#号
  • 多行注释使用三个连续单引号'''或三个双引号"""
  • 使用\作为行连接符

三、对象

  1. Python中，一切皆对象。
  2. 每个对象由：标识（identity）、类型（type）、value（值）组成 
  3. 变量位于：栈内存；对象位于：堆内存。

不需要写类型，只要直接写值就可以了，python会自动识别变量类型。 

        可以使用下面操作分别打印对象的构成。

print(a)
print(id(a))
print(type(a))

四、标识符

标识符规则：用于变量、函数、类、模块等的名称。

  1. 区分大小写。
  2. 第一个字符必须是字母、下划线。其后的字符是：字母、数字、下划线
  3. 不能使用关键字。比如：if、or、while等
  4. 以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如：__init__是类的构造函数
  5. 可以使用帮助系统查看关键字 
>>> help()

help> keywords

五、删除变量和垃圾回收机制

  1. 可以通过del语句删除不再使用的变量。
  2. 如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间。
a=123
del a
print(a)
//会报错

六、系列解包赋值

        系列数据赋值给对应相同个数的变量（个数必须保持一致）

a,b,c=4,5,6;

a=4;b=5;c=6;

a,b=1,2

a,b=b,a  #变量值互换

print(a,b)

七、基本运算符

/

浮点数除法

8/2

4.0

//

整数除法

7//2

3

%

模（取余）

7%4

3

**

幂

2**3

8

  •  使用divmod()函数同时得到商和余数，返回一个元组。

八、数值类型相关

1. 三种进制 

  • 0b或0B，二进制 0 1
  • 0o或0O，八进制 0 1 2 3 4 5 6 7
  • 0x或0X，十六进制 0 1 2 3 4 5 6 7 8 9 a b c d e f

 2. 使用int()实现类型转换：

  • 浮点数直接舍去小数部分。如：int(9.9)结果是：9
  • 布尔值True转为1，False转为0。 如：int(True)结果是1
  • 字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错

3. 自动转型： 

表达式结果自动转型成浮点数。 

        Python3中，int可以存储任意大小的整数，long被取消，整数可以任意大。

        round(value) 可以返回四舍五入的值，不会改变原有的值而是生成一个新的值。 

         Python3中，把True和False定义成了关键字，但是本质还是1和0，甚至可以数字相加。

在Python语言中有一些特殊的布尔值类型为False，例如False、0、0.0、空置None、空序列对象（空列表、孔元组、空集合、空字典、空字符串）、空range对象、空迭代对象。其他情况，均为True。 

a = True 
b = 3
c = a+b 
print(c) #4
print(bool("")) #False
print(bool([])) #False
print(bool(None)) #False
print(bool(0)) #False
print(bool("False")) #True

4. 增强型赋值运算

+=

a+=2

a=a+2

-=

a-=2

a=a-2

*=

a*=2

a=a*2

/=

a/=2

a=a/2

//=

a//=2

a=a//2

**=

a**=2

a=a**2

%=

a%=2

a=a%2

y *= x+2

y=y*(x+2)

九、关于时间

time.time()获得当前时刻，返回值是以秒为单位，带微秒（1/1000毫秒）精度的浮点值。例如：1635063628.5632517

1970年1月1日0：00开始计算。

import time
b = int(time.time())
totalMinutes = b//60
totalHours = totalMinutes//60
totalDays = totalHours//24
totalYears = totalDays//365

 十、运算符

1. 逻辑运算符 

运算符

格式

说明

or 逻辑或

x or y

x为true，则不计算y，直接返回true；x为false，则返回y

and 逻辑与

x and y

x为true，则返回y的值；x为false，则不计算y，直接返回false

not 逻辑非

not x

x为true，返回false；x为false，返回true

#测试逻辑运算符
a,b,c=10,20,30
print((a<b) and (b<c))   #and并且  输出结果是True
print((a>b) or (b>c))    #or或者   输出结果是False
print(not(b<c))         #not非     输出结果是False

2. 比较运算符 

        关系运算符可以连用！

a = 4
print(a<=30)
#关系运算符可以连用
if(3<a<10):
    print("a在3和10之间")

3. 位运算符

把数字看作二进制来进行计算的。

运算符

描述

&

按位与运算符: 参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则0

|

按位或运算符: 只要对应的二个二进位有一个为1时,结果为就为1.

^

按位异或运算符: 当两对应的二进制位相异时,结果为1

~

按位取反运算符:对数据的每个二进制取反,既把1变为0,把0变为1,~x类似于-x-1

<<

左移动运算符:运算数的每个二进位全部左移若干位,由”<<”右边的数据指定移动的位数,高位丢弃,低位补0

>>

右移动运算符:把”>>”左边运算数的每个二进制位全部右移若干位,”>>”右边的数指定移动的位数

  • bin()可以将数字转成二进制表示
  • 左移1位相当于乘以2
  • 右移移位相当于除以2
a = 0b11001
b = 0b01000

print(bin(a|b))   #bin()可以将数字转成二进制表示   '0b11001'
print(bin(a&b))   #与
print(bin(a^b))   #异或

print(3<<2)    #左移1位相当于乘以2.左移两位相当于：3*4
print(20>>1)   #右移移位相当于除以2

 4. 加法操作补充

  • 数字相加 3+2 结果是 5
  • 字符串拼接 “3”+“2”结果是 “32”
  • 列表、元组等合并 [10,20,30]+[5,10,100]结果是[10,20,30,5,10,100]

5. 乘法操作补充 

  • 数字相乘 3*2 结果是 6
  • 字符串复制 “sxt”*3 结果是 ”sxtsxtsxt”
  • 列表、元组等复制 [10,20,30]*3 结果是 [10,20,30,10,20,30,10,20,30]

6. 增强赋值运算符

与C和JAVA不一样，Python不支持自增(++)和自减(--)！

运算符

描述

示例

等价于

+=

加法赋值字符串拼接

sum += na += “sxt”

sum = sum + na = a + “sxt”

-=

减法赋值

num1 -= n

num = num - n

*=

乘法赋值

a *= b

a = a * b

/=

浮点除赋值

a/=b

a = a / b

//=

整数除赋值

a//=b

a = a//b

%=

取余赋值

a%=b

a = a % b

**=

幂运算赋值

a**=2

a = a**2

<<=

左移赋值

a<<=2

a = a<<2

>>=

右移赋值

a>>=2

a = a>>2

&=

按位与赋值

a&=b

a = a&b

|=

按位或赋值

a|=b

a=a|b

^=

按位异或赋值

a^=b

a = a^b

7. 同一运算符 

 同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。 

运算符

描述

is

is 是判断两个标识符是不是引用同一个对象

is not

is not 是判断两个标识符是不是引用不同对象

 is 与 == 区别：

  • is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。
  • == 用于判断引用变量引用对象的值是否相等，默认调用对象的 __eq__()方法。

is 运算符比 == 效率高，在变量和None进行比较时，应该使用 is

8. 整数缓存问题

  • 命令行模式下，Python仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来C语言底层用数组实现，连续分配空间，便于查找，而并非是所有整数对象。
  • 文件模式下，所有数字都会被缓存，范围是：[-无穷大,+无穷大])。缓存实现：[-5,256]仍然底层用数组实现；不在[-5,256]出现的数，缓存到链表中，不连续分配空间。
a = 1000
2b = 1000
3a == b   #True
4a is b   #命令行下是False。 文件下执行是True
5c = 10
6d = 10
7c is d   #True

9. 成员运算符

        适用于字符串，列表或元组 

运算符

描述

in

如果在指定的序列中找到值返回 True，否则返回 False

not in

不在，则返回True

a = "python"
b = "py"
print(b in a)        #True
c = [10,20,30]
print(10 not in c)   #False

10. 运算符优先级问题

位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

运算符

描述

**

指数 (最高优先级)

~

按位翻转

* / % //

乘，除，取模和取整除

+ -

加法减法

>> <<

右移，左移运算符

&

位 'AND'

^ |

位运算符

<= < > >=

比较运算符

<> == !=

等于运算符

= %= /= //= -= += *= **=

赋值运算符

is is not

身份运算符

in not in

成员运算符

not or and

逻辑运算符

 11. 基本运算符总结

运算符

说明

and , or , not

布尔与、布尔或、布尔非

is , is not

同一性判断，判断是否为同一个对象

in , not in

判断是否在指定序列中

<,<=,>,>=,!=,==

比较值是否相当，可以连用

| ^ &

按位或，按位异或、按位与

<<, >>

移位

~

按位翻转

+,-,*,/,//,%

加，减，乘，浮点除、整数除、取余

**

幂运算

 十一、字符串

1. 基本特点

  • 字符串的本质是：字符序列。
  • Python不支持单字符类型，单字符也是作为一个字符串使用的。

Python的字符串是不可变的，我们无法对原字符串做任何修改。但，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。 

 2. 字符串的编码

Python3直接支持Unicode，可以表示世界上任何书面语言的字符。Python3的字符默认就是16位Unicode编码，ASCII码是Unicode编码的子集。

  • 使用内置函数ord()可以把字符转换成对应的Unicode码；
  • 使用内置函数chr()可以把十进制数字转换成对应的字符。 
>>> ord('A')        #65
>>> ord('高')        #39640
>>> chr(66)         #'B'
>>> ord('淇')        #28103

 3. 使用引号创建字符串

  •  连续三个单引号或三个双引号，可以帮助我们创建多行字符串。在长字符串中会保留原始的格式。
s='''
  I
    Love
        Python
  '''
print(s)

 4. 空字符串和len()函数

  • Python允许空字符串的存在，不包含任何字符且长度为0。
  • len()用于计算字符串含有多少字符。一个汉字也算一个字符。

5. 转义字符

转义字符

描述

(在行尾时)

续行符

\

反斜杠符号

'

单引号

"

双引号

\b

退格(Backspace)

\n

换行

\t

横向制表符

\r

回车

 6. 字符串拼接、复制、不换行打印

  • 可以使用+将多个字符串拼接起来。例如：’aa’+ ’bb’ 结果是’aabb’
  • 如果+两边都是字符串，则拼接。
  • 如果+两边都是数字，则加法运算
  • 如果+两边类型不同，则抛出异常 
  • 可以将多个字面字符串直接放到一起实现拼接。例如：’aa’’bb’结果是’aabb’
  • 使用*可以实现字符串复制
a = 'abc'*3  #结果:'abcabcabc'

调用print时，会自动打印一个换行符。如不想自动添加换行符。可以自己通过参数end = “任意字符串”。实现末尾添加任何内容：

print("ab",end=' ') print("ab",end='##') print("ab")

运行结果：ab ab##ab

7. 从控制台读取字符串

可以使用input()从控制台读取键盘输入的内容。

myname = input("请输入名字:")
print("您的名字是："+myname)

 8. replace()实现字符串替换

字符串是“不可改变”的，我们通过[]可以获取字符串指定位置的字符，但是我们不能改变字符串。 只能通过创建新的字符串来实现。

>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a = a.replace('c','高')
'ab高defghijklmnopqrstuvwxyz'

 实际上我们是创建了新的字符串对象，并指向了变量a，而不是修改了以前的字符串。

  • str()可以帮助我们将其他数据类型转换为字符串。 

当我们调用print()函数时，解释器自动调用了str()将非字符串的对象转成了字符串 

9. 使用[ ]提取字符 

字符串的本质就是字符序列，我们可以通过在字符串后面添加[]，在[]里面指定偏移量，可以提取该位置的单个字符。

  1. 正向搜索：最左侧第一个字符，偏移量是0，第二个偏移量是1，以此类推。直到len(str)-1为止。
  2. 反向搜索：最右侧第一个字符，偏移量是-1，倒数第二个偏移量是-2，以此类推，直到-len(str)为止。
>>> a = 'abcdefghijklmnopqrstuvwxyz'
>>> a
'abcdefghijklmnopqrstuvwxyz'
>>> a[0]
'a'
>>> a[3]
'd'
>>> a[26-1]
'z'
>>> a[-1]
'z'
>>> a[-26]
'a'
>>> a[-30]
Traceback (most recent call last):
  File "", line 1, in 
    a[-30]
IndexError: string index out of range

10. 字符串切片slice操作

切片slice操作可以让我们快速的提取子字符串。标准格式为：

 [起始偏移量start：终止偏移量end：步长step]

典型操作(三个量为正数的情况)如下：

操作和说明

示例

结果

[:] 提取整个字符串

“abcdef”[:]

“abcdef”

[start:]从start索引开始到结尾

“abcdef”[2:]

“cdef”

[:end]从头开始直到end-1

“abcdef”[:2]

“ab”

[start:end]从start到end-1

“abcdef”[2:4]

“cd”

[start:end:step]从start提取到end-1，步长是step

“abcdef”[1:5:2]

“bd”

示例

说明

结果

"abcdefghijklmnopqrstuvwxyz"[-3:]

倒数三个

“xyz”

"abcdefghijklmnopqrstuvwxyz"[-8:-3]

倒数第八个到倒数第三个(包头不包尾)

'stuvw'

"abcdefghijklmnopqrstuvwxyz"[::-1]

步长为负，从右到左反向提取

'zyxwvutsrqponmlkjihgfedcba'

 切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于0则会当做0，终止偏移量大于“长度-1”会被当成-1。

11. split()分割和join()合并 

split()可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。

如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)。示例代码如下： 

>>> a = "to be or not to be"
>>> a.split()
['to', 'be', 'or', 'not', 'to', 'be']
>>> a.split('be')
['to ', ' or not to ', '']

join()的作用和split()作用刚好相反，用于将一系列子字符串连接起来。示例代码如下：

>>> a = ['sxt','sxt100','sxt200']
>>> '*'.join(a)
'sxt*sxt100*sxt200'

拼接字符串要点： 使用字符串拼接符+，会生成新的字符串对象，因此不推荐使用+来拼接字符串。推荐使用join函数，因为join函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝，仅新建一次对象。

12. 字符串驻留机制和字符串比较 

字符串驻留：常量字符串只保留一份。 

c = "dd#"
d = "dd#"
print(c is d)    #True
"ab" in "abcdefg"     #true
  • 我们可以直接使用== !=对字符串进行比较，是否含有相同的字符。
  • 我们使用is, not is，判断两个对象是否同一个对象。比较的是对象的地址，即id(obj1)是否和id(obj2)相等。
  • 2022.4.24补充

只有符合标识符规则（数字，字母，下划线）的才会触发。

>>>a = "abd_33"
>>>b = "abd_33"
>>>c = "dd#"
>>>d = "dd#"
>>>a is b  #True
>>>c is d  #False

13. 字符串常用方法汇总 

常用查找方法

方法和使用示例

说明

结果

len(a)

字符串长度

96

a.startswith('ab')

以指定字符串开头

True

a.endswith('z')

以指定字符串结尾

True

a.find('g')

第一次出现指定字符串的位置

2

a.rfind('g')

最后一次出现指定字符串的位置

29

a.count("bb")

指定字符串出现了几次

3

a.isalnum()

所有字符全是字母或数字

False

去除首尾信息 

我们可以通过strip()去除字符串首尾指定信息。通过lstrip()去除字符串左边指定信息，rstrip()去除字符串右边指定信息。 

>>> "*s*x*t*".strip("*")
's*x*t'
>>> "*s*x*t*".lstrip("*")
's*x*t*'
>>> "*s*x*t*".rstrip("*")
'*s*x*t'
>>> "  s xt  ".strip()
's xt'

 大小写转换

a.capitalize()

产生新的字符串,首字母大写

a.title()

产生新的字符串,每个单词都首字母大写

a.upper()

产生新的字符串,所有字符全转成大写

a.lower()

产生新的字符串,所有字符全转成小写

a.swapcase()

产生新的,所有字母大小写转换

 格式排版

center()、ljust()、rjust()这三个函数用于对字符串实现排版。 

>>> a="SXT"
>>> a.center(10,"*")
'***SXT****'
>>> a.center(10)
'   SXT    '
>>> a.ljust(10,"*")
'SXT*******'

特征判断方法

  1. isalnum() 是否为字母或数字
  2. isalpha() 检测字符串是否只由字母组成(含汉字)
  3. isdigit() 检测字符串是否只由数字组成
  4. isspace() 检测是否为空白符
  5. isupper() 是否为大写字母
  6. islower() 是否为小写字母
>>> "sxt100".isalnum()
 True
 >>> "abs我真帅".isalpha()
 True
 >>> "234.3".isdigit()
 False
 >>> "23423".isdigit()
 True
 >>> "aB".isupper()
 False
 >>> "A".isupper()
 True
 >>> "\t\n".isspace()
 True

14. 字符串的格式化

format()基本用法

  • 基本语法是通过 {} 和:来代替以前的 % 。
  • format()
>>> a = "名字是:{0},年龄是：{1}"
>>> a.format("帅气的我",19)
'名字是:帅气的我,年龄是：19'
>>> a.format("笨猪",6)
'名字是:笨猪,年龄是：6'
>>> b = "名字是：{0}，年龄是{1}。{0}是个好小伙"
>>> b.format("帅气的我",19)
'名字是：帅气的我，年龄是19。帅气的我是个好小伙'
>>> c = "名字是{name}，年龄是{age}"
>>> c.format(age=19,name='帅气的我')
'名字是帅气的我，年龄是19'

我们可以通过{索引}/{参数名}，直接映射参数值，实现对字符串的格式化，非常方便。

15. 填充与对齐 

  • 填充常跟对齐一起使用
  • ^、<、>分别是居中、左对齐、右对齐，后面带宽度
  • :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
>>> "{:*>8}".format("245")
'*****245'
>>> "我是{0},我喜欢数字{1:*^8}".format("笨蛋","666")
'我是笨蛋,我喜欢数字**666***'

 16. 数字格式化

浮点数通过f，整数通过d进行需要的格式化。案例如下： 

>>> a = "我是{0}，我的存款有{1:.2f}"
>>> a.format("猪猪",38.234342)
'我是猪猪，我的存款有38.23'

数字

格式

输出

描述

3.1415926

{:.2f}

3.14

保留小数点后两位

3.1415926

{:+.2f}

+3.14

带符号保留小数点后两位

2.71828

{:.0f}

3

不带小数+四舍五入

5

{:0>2d}

05

数字补零 (填充左边, 宽度为2)

5

{:x<4d}

5xxx

数字补x (填充右边, 宽度为4)

10

{:x<4d}

10xx

数字补x (填充右边, 宽度为4)

1000000

{:,}

1,000,000

以逗号分隔的数字格式

0.25

{:.2%}

25.00%

百分比格式

1000000000

{:.2e}

1.00E+09

指数记法

13

{:10d}

13

右对齐 (默认, 宽度为10)

13

{:<10d}

13

左对齐 (宽度为10)

13

{:^10d}

13

中间对齐 (宽度为10)

>>>a = '%+.2f' % 53.61666
>>>a
    '+53.62'

17. 可变字符串

  • Python中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象。
  • 确实需要原地修改字符串，可以使用io.StringIO对象或array模块
import io
s = "hello, pigpig"
sio = io.StringIO(s) #可变字符串
print(sio)
print(sio.getvalue())
sio.seek(7) #指针到索引7的位置
sio.write("***")
print(sio.getvalue())
v1 = sio.getvalue()
print("v1:"+v1)
char7 = sio.seek(7) #指针知道索引7这个位置
sio.write("fatfat")
v2 = sio.getvalue()
print("v2:"+v2)

<_io.StringIO object at 0x000001A95C8D76D0>
hello, pigpig
hello, ***pig
v1:hello, ***pig
v2:hello, fatfat

18. 类型转换总结 

类型转换

int(x [,base])

将x转换为一个整数

long(x [,base] )

将x转换为一个长整数

float(x)

将x转换到一个浮点数

complex(real[,imag])

创建一个复数

str(x)

将对象 x 转换为字符串

repr(x)

将对象 x 转换为表达式字符串

eval（str)

用来计算在字符串中的有效Python表达式,并返回一个对象

Complex(A)

将参数转换为复数型

tuple(s)

将序列 s 转换为一个元组

list(s)

将序列 s 转换为一个列表

set(s)

转换为可变集合

dict(d)

创建一个字典。d 必须是一个序列 (key,value)元组

frozenset(s)

转换为不可变集合

chr(x)

将一个整数转换为一个字符

unichr(x)

将一个整数转换为Unicode字符

ord(x)

将一个字符转换为它的整数值

hex(x)

将一个整数转换为一个十六进制字符串

oct(x)

将一个整数转换为一个八进制字符串

#类型转换

#转换为int
print('int()默认情况下为：', int())
print('str字符型转换为int：', int('010'))
print('float浮点型转换为int：', int(234.23))
#十进制数10，对应的2进制，8进制，10进制，16进制分别是：1010,12,10,0xa
print('int(\'0xa\', 16) = ', int('0xa', 16))
print('int(\'10\', 10) = ', int('10', 10))
print('int(\'12\', 8) = ', int('12', 8))
print('int(\'1010\', 2) = ', int('1010', 2))

#转换为float
print('float()默认情况下为：', float())
print('str字符型转换为float：', float('123.01'))
print('int浮点型转换为float：', float(32))

#转换为complex
print('创建一个复数(实部+虚部)：', complex(12, 43))
print('创建一个复数(实部+虚部)：', complex(12))

#转换为str字符串
print('str()默认情况下为：', str())
print('float型转换为str：', str(232.33))
print('int转换为str：', str(32))
lists = ['a', 'b', 'e', 'c', 'd', 'a']
print('列表list转换为str:', ''.join(lists))

#转换为list
strs = 'hongten'
print('序列strs转换为list:', list(strs))

#转换为tuple
print('列表list转换为tuple:', tuple(lists))

#字符和整数之间的转换
print('整数转换为字符chr:', chr(67))
print('字符chr转换为整数:', ord('C'))

print('整数转16进制数:', hex(12))
print('整数转8进制数:', oct(12))

#输出结果
int()默认情况下为： 0
str字符型转换为int： 10
float浮点型转换为int： 234
int('0xa', 16) =  10
int('10', 10) =  10
int('12', 8) =  10
int('1010', 2) =  10
float()默认情况下为： 0.0
str字符型转换为float： 123.01
int浮点型转换为float： 32.0
创建一个复数(实部+虚部)： (12+43j)
创建一个复数(实部+虚部)： (12+0j)
str()默认情况下为： 
float型转换为str： 232.33
int转换为str： 32
列表list转换为str: abecda
序列strs转换为list: ['h', 'o', 'n', 'g', 't', 'e', 'n']
列表list转换为tuple: ('a', 'b', 'e', 'c', 'd', 'a')
整数转换为字符chr: C
字符chr转换为整数: 67
整数转16进制数: 0xc
整数转8进制数: 0o14

进程已结束,退出代码0