python语言学习记录

一些常用的函数

isinstance 和 type 用于查询变量所指的数据类型。

type(a)  
isinstance(a, int)

区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

通过使用del语句删除单个或多个对象

del a

数值运算

>>>2 / 4  # 除法，得到一个浮点数
0.5
>>>2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

布尔运算

布尔运算，包含三个布尔操作符，即 and ，or ， not
优先级：not > and > or

print(False or True and False) #False
print(True or not True and False) #True
print(not False and True or not True) #True
其实也就是下面的顺序
print(False or (True and False))
print(True or ((not True) and False))
print(((not False) and True) or (not True))

（一） 基本数据类型

①String(字符串)

❤不可变 str = ‘Runoob’

Python 字符串不能被改变。
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：

str = 'Runoob'
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
RunoobRunoob

❤访问字符串中的值

索引值以 0 为开始值，-1 为从末尾的开始位置。

str='ABCDEFGHIJKLMN'
print(str[0:14])
ABCDEFGHIJKLMN
print(str[0:13])
ABCDEFGHIJKLM
print(str[1:3])
BC #类似于前闭后开的模式

❤字符串更新

虽然字符串不能更改，但是可以截取字符串中的一部分并且与其他字段拼接。

str1='hello abc'
str2=str1[:6]+'def'
print(str2)
hello def

❤转义字符

\(在行尾时)	续行符	
>>> print("line1 \
... line2 \
... line3")
line1 line2 line3
>>> 

\\	反斜杠符号	
>>> print("\\")
\

\'	单引号	
>>> print('\'')
'

\"	双引号	
>>> print("\"")
"


`\a	响铃	
>>> print("\a")执行后电脑有响声。


\b	退格(Backspace)	
>>> print("Hello \b World!")
Hello World!


\000	空	
>>> print("\000")

>>> 


\n	换行	
>>> print("\n")


>>>


\v	纵向制表符	
>>> print("Hello \v World!")
Hello 
       World!
>>>


\t	横向制表符	
>>> print("Hello \t World!")
Hello      World!
>>>


\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。	
>>> print("Hello\rWorld!")
World!
>>> print('google runoob taobao\r123456')
123456 runoob taobao


\f	换页	
>>> print("Hello \f World!")
Hello 
       World!
>>> 


\yyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行。	
>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World!


\xyy	十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行	
>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World!


\other	其它的字符以普通格式输出	 ``

❤字符串格式化

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!

      %c	 格式化字符及其ASCII码
      %s	 格式化字符串
      %d	 格式化整数
      %u	 格式化无符号整型
      %o	 格式化无符号八进制数
      %x	 格式化无符号十六进制数
      %X	 格式化无符号十六进制数（大写）
      %f	 格式化浮点数字，可指定小数点后的精度
      %e	 用科学计数法格式化浮点数
      %E	 作用同%e，用科学计数法格式化浮点数
      %g	 %f和%e的简写
      %G	 %f 和 %E 的简写
      %p	 用十六进制数格式化变量的地址

②List（列表）

可变 元素可重复list = [ ‘abcd’, 786 , 2.23, ‘runoob’, 70.2 ,1,2,3,4]

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ,1,2,3,4]
print (list[1:5])
[786, 2.23, 'runoob', 70.2]
print (list[1:5:2])
[786, 'runoob']

❤更新列表

对列表的数据项进行修改或更新，可以使用 append() 方法来添加列表项

使用 del 语句来删除列表的的元素

❤删除列表

list = ['A', 'B', 'C', 'D']
print("原始列表 : ", list)
del list[2]
print("删除第三个元素 : ", list)
原始列表 :  ['A', 'B', 'C', 'D']
删除第三个元素 :  ['A', 'B', 'D']

❤嵌套列表

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]##第一个元素的第二个元素
'b'

❤列表比较

列表比较需要引入 operator 模块的 eq 方法

import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
operator.eq(a,b):  False
operator.eq(c,b):  True

a=[1,2]
b=[2,3]
a.append(b)
print(a)
[1, 2, [2, 3]]
del a[2]
print(a)
[1, 2]
a.extend(b)
print (a)
[1, 2, 2, 3]

❤有关函数

1	len(list)
列表元素个数
2	max(list)
返回列表元素最大值
3	min(list)
返回列表元素最小值
4	list(seq)
将元组转换为列表

❤有关方法

1	list.append(obj)
在列表末尾添加新的对象
2	list.count(obj)
统计某个元素在列表中出现的次数
3	list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)
将对象插入列表
6	list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)
移除列表中某个值的第一个匹配项
8	list.reverse()
反向列表中元素
9	list.sort( key=None, reverse=False)
对原列表进行排序
10	list.clear()
清空列表
11	list.copy()
复制列表

③Tuple（元组）

不可变 tuple=(‘abcd’,786,2.23,‘ASD’,30.1)

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含0个或1个元素的元组的特殊语法：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

❤ 元组的创建

元组使用小括号 ( )，在括号中添加元素，或者不需要括号用逗号分隔开都可以
元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

tup1 = (50,)
type(tup1)
Out[17]: tuple

④Set（集合）

无序可变唯一 set(‘abcdefgh’) >>print(a-b) <{‘h’, ‘e’, ‘f’, ‘g’}

构造函数set()用于构造
特点是无序、可变、唯一
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。在 Python 中，集合使用{}表示，元素之间用逗号，分隔。
注意！创建一个空集合必须用 set()而不是{}

在创建空集合时
a=set()
而不是
a={}

a=set('abcdefgh')
b=set('abcd')
print(a-b)
{'h', 'e', 'f', 'g'}
print(a+b)
Traceback (most recent call last):
  File "F:\Anaconda3\envs\pytorch-GPU\lib\site-packages\IPython\core\interactiveshell.py", line 3508, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-25-85111a3ab660>", line 1, in <module>
    print(a+b)
TypeError: unsupported operand type(s) for +: 'set' and 'set'
print(a|b)
{'h', 'e', 'f', 'd', 'a', 'b', 'c', 'g'}
print(a&b)
{'a', 'd', 'b', 'c'}
print(a^b)
{'h', 'e', 'f', 'g'}

⑤Dictionary（字典）

无序 dict([(‘Runoob’, 1), (‘Google’, 2), (‘Taobao’, 3)])

构造函数 dict()用于构造
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
字典类型也有一些内置的函数，例如 clear()、keys()、values() 等。

输入
dict = {}
dict['one'] = "A"
dict[2]     = "B"
tinydict = {'3': 'C','4':'D', '5': 'E'}
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

输出：
F:\Anaconda3\envs\pytorch-GPU\python.exe "F:\Python folders\learn pytorch\first.demo.py" 
hello world
A
B
{'3': 'C', '4': 'D', '5': 'E'}
dict_keys(['3', '4', '5'])
dict_values(['C', 'D', 'E'])
Process finished with exit code 0

❤构造字典

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
>>> dict1={'Runoob': 1, 'Google': 2, 'Taobao': 3}

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

>>> dict(Runoob=1, Google=2, Taobao=3)
>>>dict1={'Runoob': 1, 'Google': 2, 'Taobao': 3}

>>>dic1={'A':'a','B':'b','C':'c'}

❤访问字典里的值

dic1={'A':'a','B':'b','C':'c'}
dic1['B']
Out[21]: 'b'

❤修改字典里的值

dic1={'A':'a','B':'b','C':'c'}
dic1['A']='aa'
print(dic1)
{'A': 'aa', 'B': 'b', 'C': 'c'}

❤字典内的函数

1	len(dict)
计算字典元素个数，即键的总数。	
>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(tinydict)
输出：3
2	str(dict)
输出字典，可以打印的字符串表示。	
>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(tinydict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3	type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。	
>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> type(tinydict)
<class 'dict'>

❤字典内内置方法

1	dict.clear()
删除字典内所有元素
2	dict.copy()
返回一个字典的浅复制
3	dict.fromkeys()
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None)
返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict
如果键在字典dict里返回true，否则返回false
6	dict.items()
以列表返回一个视图对象
7	dict.keys()
返回一个视图对象
8	dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)
把字典dict2的键/值对更新到dict里
10	dict.values()
返回一个视图对象
11	pop(key[,default])
删除字典 key（键）所对应的值，返回被删除的值。
12	popitem()
返回并删除字典中的最后一对键和值。

⑥bytes

不可变 bytes(“hello”, encoding=“utf-8”)

创建bytes类型方法：
（1）最常见的方式是使用 b 前缀
（2）可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码
bytes 类型表示的是不可变的二进制序列，bytes 类型中的元素是整数值（0 到 255 之间的整数）。bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

x = bytes("hello", encoding="utf-8")
x = b"hello"
y = x[1:3]  # 切片操作，得到 b"el"
z = x + b"world"  # 拼接操作，得到 b"helloworld"

Python数据类型转换

（二）运算符

算数运算符

除常规的+ - * / % 以外
** ------> 幂 - 返回x的y次幂
// ------> 取整除 - 往小的方向取整数

比较运算符

常规

赋值运算符

常规
其中新增的海象运算符的理解可以参考这篇博文：
https://www.freecodecamp.org/chinese/news/introduction-to-the-walrus-operator-in-python/

位运算符

a = 0011 1100

b = 0000 1101

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

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	
(a & b) 输出结果 12 ，二进制解释： 0000 1100

|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	
(a | b) 输出结果 61 ，二进制解释： 0011 1101

^	按位异或运算符：当两对应的二进位相异时，结果为1	
(a ^ b) 输出结果 49 ，二进制解释： 0011 0001

~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	
(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。

<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	
a << 2 输出结果 240 ，二进制解释： 1111 0000

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

>a >> 2 输出结果 15 ，二进制解释： 0000 1111

逻辑运算符

and	x and y	布尔"与" 
- 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。	
(a and b) 返回 20。

or	x or y	布尔"或" 
- 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。

not	not x	布尔"非" 
- 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	
not(a and b) 返回 False。

成员逻辑符

in	

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

not in

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

if ( a in list ):
if ( b not in list ):

身份运算符

is	

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

is not

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

is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

>>>a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

数字运算

在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：

price=2
tax=3
price * tax
Out[12]: 6
price + _
Out[13]: 8

 round() 函数是Python中的一个内置函数。 它返回 x 的小数点指定舍入 n 位数后的值。

数学函数

ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5

floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4

round(x [,n])	
返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。准确的说是保留值将保留到离上一位更近的一端。

abs(x)	返回数字的绝对值，如abs(-10) 返回 10

cmp(x, y)
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。

exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x)	以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0

log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0

max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。

min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。

modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

pow(x, y)	x**y 运算后的值。

sqrt(x)	返回数字x的平方根。

随机数函数

choice(seq)
从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

randrange ([start,] stop [,step])
从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1

random()
随机生成下一个实数，它在[0,1)范围内。

seed([x])
改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。

shuffle(lst)
将序列的所有元素随机排序

uniform(x, y)
随机生成下一个实数，它在[x,y]范围内。