python3 基本语法数据类型

a,b,c,d=10,1e-2,False,1+2j
print(type(a),type(b),type(c),type(d))
print(c)
print(c+1)

<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
False
1

1. bool中True值为1 False为0
2. python 可以同时给多个变量赋值，
3. 变量赋值时Number对象就会被创建，del语句 del（a[,b...])或 del a[,b...] []为可选择
4. 复数赋值的两种方式
c=complex(1,-1)
d=2+3j

a=b=c=1
d,e=0.1,2j
del(a)
print(a)

运行出错
Traceback (most recent call last):
  File "1.py", line 4, in <module>
    print(a)
NameError: name 'a' is not defined

#复数赋值的两种方式
c=complex(1,-1)
d=2+3j
print(c)
print(d)
#运行结果
(1-1j)
(2+3j)

所有的对象都存在于系统堆上

在Python2.5乃至3.3中，将小整数位于[-5,257)之间的数，缓存在小整型对象池中。

二：数的运算

+加 -减 *乘 **幂运算 %取余运算

/ 和 // 运算区别

1./运算得要浮点数, //运算得要浮点数的整数部分(绝大多情况的到浮点数)

2.当两操作数为整数时 //运算将得到整数

			a				结论
			浮点数		整数		无论 a b 是整数还是浮点数对于 / 运算其结果为浮点数
		值	5.0		5
b	浮点数	3.0	a/b=1.667	a//b=1.0	a/b=1.667	a//b=1.0	当a b 都为整数是 // 运算将得到整数其他情况得到浮点数，小数部分为0
	整数	3	a/b=1.667	a//b=1.0	a/b=1.667	a//b=1

三、进制转换

a=20
print(hex(a))
print(oct(a))
print(bin(a))
0x14
0o24
0b10100

2.字符串String

不可以更该其子串，可以将变量重新赋值
使用"或'进行赋值
使用""" 或'''可以指定多行赋值
python 不支持单字符类型
特殊字符使用 \ 转义
在字符串前加 R或r

x='''ab
c\nd'''
#运行结果
ab
c
d

x=R'''ab
c/nd'''
#运行结果
ab
c/nd

字符串的运算

a="abcde"		b="xy"	n="无成“
操作	描述	运算	结果	额外说明
+	字符串连接	a+b	abcdexy
*	重复字符串	b*2	xyxy
[n]	通过索引来获取字符串中的字符	a[-1] 、a[-5]	e 、 a	n<len(a) and n>= - len(a)
in	成员运算符包含给的字符返回True	'ab' in a	True
not in	成员运算符 b不包含给的字符返回True	'ab' in a	False
R/r	将字符串中的转义字符不专义	a="a\nb" b=R"x\ny" print(a) print(b)	a b x\ny
%	格式输出、占位符	print("%s的第%d篇博客"%(n,a))	无成的第1篇博客	在字符串输出时，替变量占位置
max()/min()	找出最大/小字符	max(a) min(a)	e a
len()	输出字符个数	s='abc无￥' len(s)	5	统计的是字符个数

%% 百分号

%s 字符串

%d 整数

%u无符号整数 %o无符号八进制 %x无符号十六进制

%f浮点数 %e 科学计数格式化浮点数

%g 浮点数字(根据值的大小采用%e或%f)

%p 指针(用十六进制打印值的内存地址)

%n 存储输出字符的数量放进参数列表的下一个变量中

格式化符号

符号

描述

实例

定义宽度或者小数点精度

用做左对齐

在正数前面显示加号( + )

<sp>

在正数前面显示空格

在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')

显示的数字前面填充'0'而不是默认的空格

(var)

映射变量(字典参数)

m.n.

m 是显示的最小总宽度（包括整数位和小数点，还有小数部分）

若m<=整数部分，则 m无效

n 是小数点后的位数(如果可用的话)

切片

[起始：截至：步长]

步长默认为1 一个个的截取

步长=2 截取一个后隔一个再截取

>>> a="123456789"

>>> a[1]                                          #仅一位数 相对于下标检索
'2'
>>> a[-1]                                         #-1为字符串的倒数第一个字符     
'9'
>>> a[-20]                                        #a[n] n>=-len(a) and n<len(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> a[20]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range


>>> a[1:5]                                         # 步长默认为1
'2345'

>>> a[]                                            #[]内不能为空
  File "<stdin>", line 1
    a[]
      ^
SyntaxError: invalid syntax

>>> a[:]                                           #[:] 截取全部
'123456789'
>>> a[0:]                                          #[n:] 从n开始截取
'123456789'
>>> a[50:]
''

>>> a[-5:-1:1]                              #-1为字符串倒数第一个，-2为字符串倒数第二个
'5678'
>>> a[5:-1:2]   
'68'
>>> a[-110:100:2]
'13579'


>>> a[:-1]                                       #相对于a[0:-1:1]
'12345678'

# step < 0
>>> a[::-1]                                      #反向截取全部 
'987654321'

>>> a[:-110:-1]
'987654321'

>>> a[0:-1:-1]
''
>>> a[-1:0:-1]
'98765432'
>>> a[-1::-1]                                   #相当于a[-1::-1]
'987654321'

	setp > 0	setp < 0	setp = 0
start > stop
start < stop
start = stop	' ' (空)

对于字符串变量 a='helloworld'

a	h	e	l	l	o	w	o	r	l	d
正序号	0	1	2	3	4	5	6	7	8	9
负序号	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1

总结		step			附加	描述
		正	负
1	a[n] 索引				n ( n>=-len(a) and n<len(a) ）否则为空	截取一个字符
2		当且仅当 start < stop 才有意义，否则为空		step<0时，当且仅当 start > stop 才有意义，否则为空	start和stop的值为整数否则报错	以字符串的长度为基准，按步长截取，
		PS：有意义指该操作可能不为空（当起始位置与截至位置的范围不位于字符串的序号范围时为空

3列表 List [ ]

在CPython中，列表被实现为长度可变的数组。从细节上看，Python中的列表是由对其它对象的引用组成的连续数组。指向这个数组的指针及其长度被保存在一个列表头结构中。每次添加或删除一个元素时，由引用组成的数组需要该标大小（重新分配）。幸运的是，Python在创建这些数组时采用了指数过分配，所以并不是每次操作都需要改变数组的大小。

1.写在[ ]内用逗号分隔开元素列表
2.元素可以是列表（可以嵌套）
3. 元素值可更改
4.元素类型可为数、字符串、元组、列表、集合、字典
5.可被切片和截取 0为开始 -1为尾部的位置

一：len（list）返回最外层元素的个数

二：max（list）/min（list）当list元素同一类型是可以比较

三： list（seq）将元组转换成列表（仅转换最外层元素）

a=((1,2),3,(4))
print(list(a))
#运算结果
[(1, 2), 3, 4]

方法

增	list.append(obj) 在列表末尾添加新的对象	相同	不同
		l=[1,2] z={1:2,'a':'p'}	l.append(obj)		l.extend(seq)
	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表，但会在已存在的列表中添加新的内容。）	在末尾一次性追加，且无返回值	[1, 2, {1: 2, 'a': 'p'}]		[1, 2, 1, 'a'] 追加字典仅追加键
			将参数作为一个整体加入		将参数的外层元素元素加入
	list.insert(index, obj) 将对象插入列表无返回值	若index < -len(list) 则相当于list(0,obj)
		若index > len(list) 则相当于list( len(list) ,obj )
删	del(list)	删除部分		删除全部
		参数为切片时，切片结果可为空参数为索引时，若索引结果为空则出错		del(列表名)
	list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），*并且返回该元素的值*	若index值不在 [-len(list), len(list)) 范围内则报错
	list.remove(obj) 移除列表中某个值的第一个匹配项，无返回值			若列表中不存在该参数则报错
查	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置			若列表中不存在该参数则报错
	list.count(obj) 统计某个元素在列表中出现的次数（仅统计最外层）
改	list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序，cmp比较的具体规则，key比较的元素（当多维时），False 是升序（默认）
	list.reverse() 反向列表中元素，无返回值，该函数不含参数
	通过赋值更改list 切片赋值，索引赋值

4 元组 Tuple（）　

1.创建（）内逗号分隔

创建空 tup1=()

仅含一个元素 tup2=(1,)

2.元素不可修改

3.操作切片 +连接 *重复 in 成员运算符长度len(tup) min(tup) max(tup)

5 字典 Dictionary

只有可哈希的对象才能作为字典的键。Python中所有不可变的内置类型都是可哈希的。可变类型（如列表，字典和集合）就是不可哈希的，因此不能作为字典的键。

1.字典 { } 无序的键：值对的集合 ,创建空字典必须使用{}

2. 键key必须使用不可变类型同一字典 key唯一

3.内置构造函数 dict() 以及 clear() keys() values()

6 集合 set () 或 { }

python内置集合类型

set(): 可变、无序、有限，其元素是唯一的、不可变的（可哈希的）对象。
frozenset(): 一种不可变的、可哈希的、无序的集合，其元素是唯一的，不可变的哈希对象。

集合被实现为带有空值的字典，只有键才是实际的集合元素

1.创建 { } 元素间逗号隔离

set( "字符串" ) 将每个字符当作一个元素，创建空集合

set({ }) 小括号内使用{}，创建多个元素的集合

2.无法通过下标索引

3.不可变类型无法修改元素

4.操作

求交集： set1 & set2

求并集： set1 | set2

相当于set1|set2 -(set1&set2)： set1 ^ set2

求差集： set1 - set2

判断是否是子集or超集： set1.issubset(set2) or set1.issubset(set2)

转变成list or tuple: list(set1) or tuple(set1)

集合set1
求交集：	set1 & set2
求并集：	set1 \| set2
求差集：	set1 - set2
＾运算	set1 ^ set2	相当于set1\|set2 -(set1&set2)：
子集	set1.issubset(set2)
超集	set1.issubset(set2)
转成list	list(set1)
转成l tuple:	tuple(set1)
set1.add(参数)	参数不可为列表、集合、字典	参数可为bool、Number、字符串、元组（将作为整体成为集合内的一个元素）无返回值	`#TypeError: unhashable type: 'list' #TypeError: unhashable type: 'set' {('tuple', -1), 1, 3} #TypeError: unhashable type: 'dict'`
set1.add(参数)	参数为true／False时，若元素不存在１或０	参数可为bool、Number、字符串、元组（将作为整体成为集合内的一个元素）无返回值
set1.update()	参数不可为bool、Number	参数可为字符串、元组、列表、集合、字典，将参数的每个元素导入集合内	`#结果 # {1, 3, 'li', 'st'} {1, 3, 100, 'set'} # # # # {1, 'tuple', 3, -1} ##### {1, 3, 'l', 'h', 'e', 'o'}`

7 转换

1. str(x) 将对象x转换成字符串 一般是将数值转成字符串

2. repr(x) 将对象x转换成表达式字符串
repr()是将一个对象转成字符串显示，注意只是显示用，有些对象转成字符串没有直接的意思。如list,dict使用str()是无效的，但使用repr可以，这是为了看它们都有哪些值，为了显示之用。

3. dict(d) 创建一个字典 d必须是一个序列{key,vaue}元组

4 set(x) 转换成可变集合

5 frozenset(s) 转换成不可变集合

6. chr(x) 将一个整数转换成字符 unichr(x) 转换成unicode字符

7. ord(x) 将一个字符转换成整数

8. int（x) float(x)

9 eval(expression, globals=None, locals=None) --- 官方文档中的解释是，将字符串str当成有效的表达式来求值并返回计算结果。globals和locals参数是可选的，如果提供了globals参数，那么它必须是dictionary类型；如果提供了locals参数，那么它可以是任意的map对象。

总结

数据类型	字符串（string）	列表(list)	元组(tuple)	集合(set)	字典(dictionary)	描述
定义	str="asf"	l = [2, True, ‘a’]	t = (2, True, ‘a’)	a_set = {2, True, ‘a’}	d = {‘na’: ‘me’, 1: 21}
是否有序	有序	有序	有序	无序	无序	元素之间是否有顺序关系
空定义	s=""	l = [] l=list()	t=()	set()	d={}
元素可修改	否	l[0] = 23	否	否	d['na']="asd"
下标访问	str[0]	l[0]	t[0]	否	d['na']
添加元素	否 + 运算相对于重新赋值	+、append、extend、insert	不可添加	add、update	a_dict[‘new_key’] = ‘value’
删除元素	否	del、remove、pop()、pop(1)、clear	不可删除	discard、remove、pop、clear	pop、popitem、clear	remove()移除列表中某个值的第一个匹配项
元素查找	in find、index	index、count、in	in	in	通过键	index()从列表中找出某个值第一个匹配项的索引位置
布尔真值	非空	非空	非空	非空	非空	在为空时布尔真值也不为False

append(value)	把元素添加到末尾
insert(i,value)	把元素添加到任意位置
pop(）	删除末尾元素
pop(i)	删除指定位置的元素
remove(value)	直接删除某个元素值
list1.sort()	对元素进行排序