[Python-1]Python编程基本概念

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)

九、关于时间

        python中可以通过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