Python基础

一,Python的安装

略,自行百度

使用版本最好在3.7.x,且注意配置(一般默认配置)环境变量和安装包管理工具pip

二,pip工具的常用命令:

# 使用国内镜像源
pip install jieba -i http://mirrors.aliyun.com/pypi/simple --trusted-host mirrors.aliyun.com

三,Python对象模型:

对象是python语言中最基本的概念，在python中处理的一切都是对象.内置对象可直接使用,非内置对象需要导入模块才能使用.

四,变量

x = 1  # 默认整型变量
y = 'zgydddd'  # 默认str型

vPython还是一种动态类型语言，变量的类型也是可以随时变化的。

# 可以使用type()查看数据类型
x = 1  
print(type(x))  # <class 'int'>,用来看变量类型

注意几个常用运算操作:

x = 2
print(x**2)  # 4(x的2次幂)
x += 6
print(x)  # 8
x = [1,2,3]  # 列表对象
print(x[0],x[2])  # 1 2  显示指定元素

字符串和元组属于不可变序列，不能通过下标的方式来修改其中的元素值，试图修改元组中元素的值时会抛出异常。

即

x = (1,2,3)  # 元组不可变序列
x[1] = 5 # error

在Python中，允许多个变量引用同一个值:

x = 3
y = x

# 其中x和y的内存地址相同,即
id(x) == id(y)  
# 当为其中一个变量修改值以后，其内存地址将会变化，但这并不影响另一个变量
x += 6
id(x) # 变为新的地址
id(y) # 地址不变

　Python采用基于值的内存管理方式，即如不同变量赋相同的值，多个变量指向同一个值的内存空间首地址可减少内存空间的占用

Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因.

变量命名规范:

• 变量名必须以英文字母、汉字或下划线开头
• 变量名中不能有空格以及中英文标点符号
• 不能使用关键字作变量名，可以导入keyword模块后使用print(keyword.kwlist)查看所有Python关键字
• 变量名对英文字母的大小写敏感

Python中的整数类型可以分为:

• 十进制整数
• 十六进制整数
• 八进制整数
• 二进制整数

Python内置支持复数类型:

a = 3 + 4j
b = 5 + 6j
c = a + b  # 复数加
c = a * b  
c = a / b

print(c.read)  # 查看复数实部
print(c.imag)  # 查看复数虚部

print(c.conjugate())  # c的共轭

注意在3.6.x后的python版本后,支持使用数字中间位置使用单个下划线作为分隔来提高数字的可读性,类似于分隔符

1_000_00  # 100000

1_2.3_45  # 12.345

字符串:

str = 'china'

str = "hello world"

# 三引号可以换行
str = '''
长文本显示
'''

常用转义字符:

字符串界定符前面加字母r或R表示原始字符串

# 如
path = 'C:\Windows\notepad.exe'
print(path) 
""" 输出
C:\Windows
otepad.exe
"""
path = r'C:\Windows\notepad.exe'
print(path)  # C:\Windows\notepad.exe  字符不转义

五.运算符

为了更好的理解运算符,下面详细操作使用方式:

# :=    俗称海象运算符,赋值运算.python3.8新增

# 二选一运算符,  value1 if condition else value2
print('aaa') if 1>2 else print('bbb')

# or
print(1 or 1) # 1
# and 
print(1 and 0)

# not 逻辑非运算符，对于表达式not x，如果x的值等价于True则返回False，否则返回True

# 列表连接
[1,2,3] + [4,5,6]
# [1, 2, 3, 4, 5, 6]

# 连接字符串
'abcd' + '1234'
# 'abcd1234'

# Python内部把True当作1处理,把False当作0处理
True + 3 
# 4
False + 3 
3
# 3

注意：不支持字符与数字相加，抛出异常

# * 号运算符的使用
2.0 * 3  # 浮点数与整数相乘
# 6.0

(3+4j) * 2                  # 复数与整数相乘
# (6+8j)
(3+4j) * (3-4j)             # 复数与复数相乘
# (25+0j)
'a' * 10                    # 字符串重复
# 'aaaaaaaaaa'
[1,2,3] * 3                 # 列表重复
# [1, 2, 3, 1, 2, 3, 1, 2, 3]
(1,2,3) * 3                 # 元组重复
# (1, 2, 3, 1, 2, 3, 1, 2, 3)

# python中除法有两种，/ 和 // 分别表示除法和整数运算
>>> 3.0 // 5
0.0
>>> 3 / 5
0.6
# %运算符除去可以用于字符串格式化之外，还可以对整数和浮点数计算余数。

关系运算符可以连用.如

1 < 3 < 5 					# 等价于1 < 3 and 3 < 5

'Hello' > 'world'             # 比较字符串大小
False

[1, 2, 3] < [1, 2, 4]           # 比较列表大小

'Hello' > 3                     # 字符串和数字不能比较

{1, 2, 3} < {1, 2, 3, 4}        # 测试是否真子集

# in 的使用：成员测试运算符in用于成员测试，即测试一个对象是否为另一个对象的元素

'abc' in 'abcdefg'   # 子字符串测试

for i in (3, 5, 7):  # 循环，成员遍历
    print(i, end='\t')   # 注意，这里打两个回车才会执行
3 5 7

5 in range(1, 10, 1) # range()是用来生成指定范围数字的内置函数

# is 的使用：is用来测试两个对象是否引用同一个地址，如果是则返回True，否则返回False
3 is 3
# true
x = [300, 300, 300]
x[0] is x[1]  # true 内存中只有一份

如果两个对象引用了同一个对象，二者具有相同的内存地址

位于运算：

• &：按位与运算符，参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0；

• |：按位或运算符，只要对应的二个二进位有一个为1时，结果位就为1；

• ^：按位异或运算符，当两对应的二进位相异时，结果为1；

• ~：按位取反运算符，对数据的每个二进制位取反，即把1变为0，把0变为1；

• >>：右移动运算符，把 >> 左边的运算数的各二进位全部右移若干位，>> 右边的数指定移动的位数；

• <<：左移动运算符，运算数的各二进位全部左移若干位，由 << 右边的数指定移动的位数，高位丢弃，低位补0。

集合的交集、并集、对称差集等运算借助于位运算符来实现，差集则使用减号运算符实现.如下

{1, 2, 3} | {3, 4, 5}         # 并集，自动去除重复元素
{1, 2, 3, 4, 5}

{1, 2, 3} & {3, 4, 5}         # 交集
{3}

{1, 2, 3} ^ {3, 4, 5}         # 对称差集
{1, 2, 4, 5}

{1, 2, 3} - {3, 4, 5}         # 差集
{1, 2}

and和or具有惰性求值特点，只计算必须计算的表达式

# 逗号并不是运算符，只是一个普通分隔符
'a' in 'b', 'a'
(False, 'a')
'a' in ('b', 'a')
True

Python不支持++和--运算符，只是两个连续的加号和减号

下标运算符和属性访问：

import random  #  random内置函数,需导入
data = random.choices(range(10),k=5)  # k 选取几个值,
print(data) # [9, 3, 6, 2, 7]
data.sort() # 调用列表对象的sort()方法,排序
print(data) # [0, 0, 3, 4, 6]
print(data[3],data[1:2])  # 访问列表中下标为3的元素,访问列表中下标介于[1,2)区间的元素
# 3 [1]
try:  # 可能随机不产生2
    data.remove(2) # 调用列表方法remove()删除第一个2
    print(data)
except:
    print('列表中无2')
finally:

    data = {'red':(1,0,0), 'green':(0,1,0), 'blue':(0,0,1)}
    print(data['red'])            # 使用“键”做下标，访问对应的“值”
# (1, 0, 0)


    data = ['red', 'Green', 'blue']
    data.sort(key=str.lower)      # 按照转换成小写之后的大小排序
    print(data)

下面一部分需要3.8.x的环境：

text = '''
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
'''
if (c:=text.count('is')) > 0:
    print(f'出现次数{c}')
else:
    print('没有出现')

if (c:=text.count('isis')) > 0:
    print(f'出现次数{c}')
else:
    print('没有出现')

text = 'abcd'
if (length:=len(text)) < 5:
    print(f'字符串长度为{length}，太短了')
else:
    print(f'字符串长度为{length}，符合要求')

    
# 在使用 data:=进行遍历时，data在循环之外也可使用
for num in (data:=[1, 2, 3]):
    print(num)
# 赋值方式为：
(a := 5)
# 5

>>> dir(__builtins__)  #  

六，内置