python速成

PYTHON数据类型/组/运算符
第一天
1.PYTHON的基本数据类型
number 数字类型 int 整数 float 浮点数
type(11)→ <class ‘int’> type(11.0)→ <class ‘float’>
type(2//2)→ <class ‘int’> type(2/2)→ <class ‘float’>

1.1.进制转换
10进制0、1、2、3…7、8、9、10 2进制 0、1、10(0b10)
8进制0、1…6、7、10(0o10) 16进制0、1…9、A(10)、B、C、D、E、F、10(0x10)
8、10、16进制转换 2进制 bin(10)→’0b1010’ bin(0o7)→’0b111’ bin(0xE)→’0b1110’
2、8、16进制转换 10进制 int(0b11)→ 3 int(0o7)→ 7 int(0xF)→ 15
2、8、10进制转换 16进制 hex(0b11)→’0x3’ hex(0o7)→’0x7’ hex(19)→’0x13’
2、10、16进制转换 8进制 oct(0b11)→’0o3’ oct(11)→’0o13’ oct(0x9)→’0o11’

bool布尔类型 真/假 true/false complex 复数 36j
type(True) → <class ‘bool’> int(True) → 1 bool(1)→ True
type(False) → <class ‘bool’> int(False) → 0 bool(0)→ False
bool(‘abc’) → True bool([1,2,3])→ True bool({1,2,3})→ True
bool(’’) → False bool([]) → False bool({}) → False
2,8,10,16进制数字只有0是 False 其它是 True
非数字，空值是 False 其它是 True

2. str 字符串：单引号，双引号，三引号 成对出现？\转义字符 \n 换行

type(1) → <class ‘int’> type(‘1’) → <class ‘str’>
"let’s go"→ “let’s go” 或者写成 ‘let’s go’ 不能写成 ‘let’s go’

换行 \n 换行 相当于回车键 默认展示79个字符 超出会换行
‘’’
hello world
hello world
hello world
‘’’
‘\nhello world\nhello world\nhello world\n’
“”"
hello world
hello world
hello world
“”"
‘\nhello world\nhello world\nhello world\n’
print(‘hello world\nhello world\nhello world’) → hello world
hello world
单引号双引号都一样 hello world
字符串换行的一种方式（输入\） ‘hello
world’ → ‘helloworld’

转义字符：特殊字符/无法看见的字符/与语言本身有语法冲突
\转义字符 \n 换行 \‘单引号 \t 横向制表符 \r 回车
print(‘hello \n world’) → hello \n world
print(‘c:\northwind\northwest’) → c:\northwind\northwest
print(r’c:\northwind\northwest’) → c:\northwind\northwest
加 r 之后 不是一个普通的字符串 而是原始的字符串

3.字符串的运算
拼接 字符串不能*字符串
“hello”+“world” → ‘helloworld’ “hello”*3 → ‘hellohellohello’
取字符串 正整数从0开始的系号 “hello world”[0] → ‘h’
负数[-n]往前数n次 “hello world”[-1] → ‘d’

截取到下一位 “hello world”[0:5] → ‘hello’
步长：往前数字符串加起来"hello world"[0:-1]→’hello worl’ -1截取到的下一位
“hello world”[6:11] → ‘world’ 正常截取 “hello world”[:-6] → ‘hello’
“hello world”[6:] → 'world’去后截取 去前截取
“hello world”[-5:] → 'world’去后截取

第二天
4.组的概念
列表 list 使用[ ]表示 列表里面有列表 叫嵌套列表
type([1,2,3,4,5,6]) → <class ‘list’>
type([“hello”,“world”,1,9,True,False]) → <class ‘list’>
type([[1,2],“world”,1,[‘s’,‘t’],True,False]) → <class ‘list’>
type([[1,2],[“world”,1],[‘s’,‘t’],[True,False]]) → <class ‘list’>
访问列表
[‘w’,‘x’,‘y’,‘z’][0] →’w’ 单一数字访问是字符 [‘w’,‘x’,‘y’,‘z’][3] → ‘z’
[‘w’,‘x’,‘y’,‘z’][0:2] → [‘w’, ‘x’] [‘w’,‘x’,‘y’,‘z’][-2:] → [‘y’, ‘z’]
带冒号：访问是列表[‘w’,‘x’,‘y’,‘z’][-1:] → [‘z’]
[‘w’,‘x’]*3 → [‘w’, ‘x’, ‘w’, ‘x’, ‘w’, ‘x’]
[‘w’,‘x’] + [‘y’,‘z’] → [‘w’, ‘x’, ‘y’, ‘z’]
[‘w’, ‘x’, ‘y’, ‘z’] - [‘w’] 列表不能相减

元组 tuple 有序 不可变 使用 ( )表示 + *都和上面一样
type((1,2,3,4,5)) → <class ‘tuple’>
(1,2,3,True)[0] → 1
(1,2,3,True)[0:2] → (1, 2)
(1,2,3,True)[1:2] → (2,) 带冒号表示出元组，单个数字的元组(1,)

type((1,2,3)) → <class ‘tuple’> type(1) → <class ‘int’>
type([1,2,3]) → <class ‘list’> type(‘hello’) → <class ‘str’>
type((1)) → <class ‘int’> 数学运算符() 会运算 type(())→ <class ‘tuple’>
type([1]) → <class ‘list’>
type((1,)) → <class ‘tuple’>

总结：
int,float,bool,str,list,tuple
str,list,tuple 序列(有序) 共有的操作 可获取(截取)元素[0] 可切片[0:2] + *
3 in [1,2,3,4,5,6] → True 3 not in [1,2,3,4,5,6] → False
len([1,2,3,4,5,6]) → 6 max(“sxhaiyzh”)→’z’ min([1,2,3,4,5,6]) → 1
len(“sxhaiyzh”) → 8 min(“sxhaiyzh”)→’a’ max([1,2,3,4,5,6]) → 6

ascll码 访问 ord : ord(‘w’)→119 ord(‘d’)→100 ord(’ ')→32

集合 set 无序(不支持切片，取数) 不重复 使用 { }
type({1,2,3,4,5,6}) → <class ‘set’> {1,1,2,2,3,3} → {1, 2, 3}
支持 len({1,2,3}) → 3 1 in {1,2,3} → True 1 not in {1,2,3} → False
{1,2,3,4,5,6} - {3,4} → {1, 2, 5, 6} 差集 集合可以求两个集合的差值
{1,2,3,4,5,6} & {3,4} → {3, 4} 交集
{1,2,3,4,5,6} | {3,4,7} → {1, 2, 3, 4, 5, 6, 7} 并集（合集）
type(set()) → <class ‘set’> len(set()) → 0

字典 dict key values 由很多的key和values组成 type({}) → <class ‘dict’>
{key1:value1,key2:value2,…keyn:valuen}
type({1:1,2:2,3:3}) → <class ‘dict’>
{“a”:1,“b”:2,“c”:3,“d”:4}[“a”] → 1
{“a”:1,“a”:2,“c”:3,“d”:4} → {‘a’: 2, ‘c’: 3, ‘d’: 4} key值不能重复
{“a”:1,“a”:2,“c”:3,“d”:4}[“a”] → 2

value:str int float list set dict
key:必须是不可变得类型 int str tuple 元组不可变
{1:“a”,‘1’:“a”,“c”:3,“d”:4} → {1: ‘a’, ‘1’: ‘a’, ‘c’: 3, ‘d’: 4}
{1:“a”,‘1’:“b”,“c”:3,“d”:4}[1] → ‘a’
{1:“a”,‘1’:“b”,“c”:3,“d”:4}[‘1’] → ‘b’

总结：
1.数字（Number）:int float bool complex
2.序列 str tuple 不可变 list 可变
set 无序，没有索引，不可切片 dict key value键值对是其基本概念

第三天
变量与运算符 id 内存地址 10进制 通常16进制比较适合计算机
变量(名字有意义) 定义一个变量 = 赋值符号
命名可读性要强，避免重复输入，可以用简单简洁得英文单词命名一个变量
规则：变量名得首字母不能包含数字（字母/数字/下划线组成）
系统关键字不能用于变量名中（保留关键字 and if import ）
变量区分大小写
变量没有类型限制 可以是 str int set dict …
非保留关键字 type print 没有必要和系统抢关键字
动态语言 int str tuple (不可改变)值类型 list set dict(可变) 引用类型

a = 1 >>> a=[1,2,3]
b=a >>> b=a
a=3 >>> a[0]=‘1’
print(b) >>> print(b) 地址没有变
1 [‘1’, 2, 3]

a=‘hello’
id(a) >>> ‘hello’[0]
3015074272624 ‘h’

a=a+‘python’ >>> id(‘hello’)
id(a) 3015074449520
3015074702064 >>> ‘hello’[0]=‘o’ 运行会报错 id 不变 str 不可变
可行得地址发生改变 TypeError: ‘str’ object does not support item assignment

id(‘hello’)
3015074449520
list tuple dict 组用的多

tuple

a = (1,2,3)
a[0] = ‘1’
TypeError: ‘tuple’ object does not support item assignment
追加append list可追加 也就是可变 上面的元组不可追加 也就是不可变

b=[1,2,3] list
b.append(4)
print(b)
[1, 2, 3, 4]
多维元组，多维列表的元素访问 元素[][][]

a=(1,2,3,[4,5,6]) >>> (1,2,3,[4,5,6])[3][2]
a[3][2] 6
6

a=(1,2,3,[4,5,6])
a[2]=‘3’ --tuple 不可变 不支持修改
TypeError: ‘tuple’ object does not support item assignment

a[3][2]=‘8’ --list 可变 支持修改
print(a)
(1, 2, 3, [4, 5, ‘8’])
说赋值 c = 1 把1赋值给变量c
算术运算符： + - * / //整除 %余数 23 乘方 数字/字符串/列表
赋值运算符： = += = /= %= *= //=先做运算再赋值
比较(关系)运算符：== != > < >= <= 返回一个布尔值 True False
逻辑运算符： and or not 主要操作布尔类型的，返回结果也是布尔类型
成员运算符： in not in
身份运算符： is is not 比较身份（内存地址）
位运算符： & | ^ - << >>
c+=1 等价于 c+1 赋值给 c 无自增自减的
a+=b 等价于 a+b 赋值给 a a/=b 等价于 a/b 赋值给 a
b-=a 等价于 b-a 赋值给 b a%=b 等价于 a%b 赋值给 a
b=a 等价于 ba 赋值给 b a=b 等价于 ab 赋值给 a

‘a’>‘b’ → False ‘abc’ > ‘abd’ → False ord(‘d’) → 100
[1,2,3] < [2,3,4]→ True (1,2,3) < (1,3,2)→ True {1,2,3} < {1,3} → False

True and True → True True and False → False
True or True → True True or False → True False or False → False
not True → False not False → True not not True → True

1 and 1 → 1 ‘a’ and ‘b’ → ‘b’ not ‘a’ → False
int float 0 表示 False 非 0 表示 True not 0.1 → False
字符串 str 空字符串 False 否则 是 True not ‘0’ → False
tuple set dict 和字符串类似 [1] or [] → [1] ‘’ and ‘b’ → ‘’
逻辑运算符返回可以是布尔值 也可以是非布尔的相关比较类型(主要看返回的布尔值)
2 and 1 → 1 and 等第二个判断完才返回 除非第一个是0直接返回 False 就近返回
0 or 1 → 1 类似 and 的道理 就近原则

成员运算符 ：1个元素是不是在另一个一组的元素中 1 in [1,2,3,4,5,6] → True
1 in (1,2,3,4,5,6) → True 1 in {1,2,3,4,5,6} → True
字典的成员运算针对 key 来取值 ‘c’ in {‘c’:1} → True

身份运算符：如果两个变量取值相等，则 is 返回 True , is 和 == 类似

1 is 1 关系比较值是否相等
True

1 is 1.0 身份比较两个身份是否相等
False
(1,2,3) == (2,1,3) → False 元组有序 {1,2,3} == {2,1,3} → True 集合无序

类型 type 判断
对象三个特征:
(value 值(关系运算),身份 id(is),类型 type(isinstance))一切都是对象
type(‘hello’) == int → False isinstance(‘hello’,int) → False
isinstance(‘hello’,(int,str,float)) → True

位运算符： & 按位与 |按位或 ^ 按位异或 ~ 按位取反 <<左移动 >>右移动
把数字当作二进制数进行运算
2 & 3 → 2 1 0 → 1 0 → 2 2 | 3 → 3 1 0 → 1 1 → 3
1 1 1 1