Python3学习笔记（1）——基础和数据类型

1    基础

1.1   输入输出

    下划线 _ 表示最后一个表达式的值

    input("提示：", )

    print("1","2")#自动加空格

    格式化输出 "abc%s%s" % ("x","y")

              'abc {x}'.format(x='123')

    str() #返回对象的字符串形式，便于人阅读

repr() #将对象转化为供解释器读取的形式,一般可以通过eval()识别

1.2   变量赋值

    ①a='ABC' #内存中创建'ABC'字符串->创建变量a,指向'ABC'

      b=a #将b指向a指向的数据'ABC'

    ②a=1;a=a+1 #创建一个a+1的新值，再赋给a

    ③a=1;b=a;a=a+1;# a和b都指向1，然后a指向了新值（a+1），b仍指向原值1

    如赋值语句a,b,c=(1,2,3)，建议加括号，提高可读性

    a = b = c = 1 (相同内存单元)

    交换值 x,y=y,x

    删除引用 delvar_a, var_b

1.3   编码

文件开头写# -*- coding: UTF-8 -*-

2    数据类型

2.1   数值

数值类型：

int（没有大小限制）、float、bool（可以和数字相加）、complex（12j+1）、（没有Python2中的long）

复数类型的内建方法num.real,num.imag,  num.conjugate()

   

运算符：

    ①//(地板除,只取整数部分) ②**(乘方) ③3<4<5#True ④% (取余数)

    ⑤* 重复（字符串、元组、列表） ⑥+ 连接（必须是同一类型，字符串、元组、列表）

    ⑦位运算符：<<、>>、^、~、&、|（仅用于整数）

运算函数：

divmod(被除数，除数)#返回(商，余数)tuple; abs(); pow(3,2)#3²;

math.floor()#得到小于原小数的最大整数; round(num [,n])#n为小数点位数

进制函数：hex(); oct(); bin(); 转换为对应进制的字符串

ASCII或unicode转换函数:chr(num);#数字转字符 ord(chr) #字符转数字

重要模块:

       decimal #十进制浮点数高精度运算模块，但是速度比float慢很多

    random  #产生多种伪随机数

    math/cmath

    operator #数字运算符的函数实现

2.2   序列

2.2.1   字符串

值不可改变

内建方法：

count(sub[,start[,end]])

返回sub在字符串里出现的次数，start,end为可选参数，决定范围

find(sub[,start[,end]])      rfind()

检测sub是否在字符串中，如果在则返回index，否则返回-1

index(sub[,start[,end]])   rindex()

类似find()不同在于如果sub不在字符串中，返回的是异常

endswith(sub[,start[,end]])

检查字符串是否以sub结尾，是返回True,否返回False

startswith(sub[,start[,end]])

检查字符串是否以sub开头，是返回True,否返回False

replace(str1,str2[,n])

用str2替换str1，如果不指定替换次数n，仅替换第一个

返回的是拷贝

upper()   lower()

将字符全部转成大写(小写)

partition(str)

查找str，返回[str前边部分，str，str后边部分]

split([str],[num])

用str（默认空格）分割字符串，num指定次数

splitlines([num])

按行分割，返回每行为元素的列表，num指定行数

strip([str])        lstrip()  rstrip()

移除字符串两侧的指定字符串str，默认移除空格

join(str)

把该字符串作为间隔，分隔 str中的字符

encode(encoding='utf-8',errors='strict')

以encoding指定的编码格式对字符串进行编码

格式化输出: "abc %s%s" %("x","y")

%s

优先用str()函数进行字符串转换

%r

优先用repr()函数进行字符串转换

%d  %i

转成有符号十进制数

%u

转成无符号十进制数

%x/%X   %#x

转成无符号十六进制数  #表示显示0x

%e/%E

科学计数法

%f/%F、%.nf、%m.n

转成浮点数(小数部分自然截断)、小数位数为n、最小宽度为m

%%

输出%

字符串类型：

r'\n\\'  #不转义

b'ABC'[0] #作为字节序列，取ASCII值

u'dada'   #unicode

2.2.2   列表[]

注意

可变对象的改变值的方法没有返回值，对原对象做操作.若要返回值，用内建函数reversed()、sorted()

创建

list1=list('abc')

创建['a','b','c']

添加

list1.append('a')

添加1个

list1.extend(['a','b','c'])

通过序列（列表、元组、字符串（每个字符都将作为一个元素））添加多个元素.

list1.insert(index,obj)

在索引量为index 的位置插入对象obj

更改

list1[2:4]=[1,2]

 

排序

list1.sort(key=None, reverse=False)

如果key 参数指定,则按照指定的方式比较各个元素。使用functools 模块中的cmp_to_key()函数。

key= cmp_to_key(lambda x,y:x.a-y.a)

如果reverse 标志被置为True,则列表以反序排列.

list1.reverse()

翻转列表

删除

del list1[0]

 

list1.remove('a')

删除列表中第一个'a'元素

弹出

val1=list1.pop(0)

弹出list1中第一个值，赋给val1.若是pop()，则弹出列表最后一个值；若不指定赋予的变量，则该值被丢弃

比较

['abc',123] < ['xyz',789]

其结果为第一个不相等元素的比较结果

计数

list1.count(obj)

返回一个对象obj 在列表中出现的次数

查找

list.index(obj, i=0, j=len(list))

返回list[k] == obj 的索引k,且必须i<=k<=j,否则异常

2.2.3   元组()

创建 tuple1=(1,'robot',('e',1),None,[1,2])#

     不可改变值，但是包含可变对象（列表）则可以改变其可变对象的值

     tuple2=('abc',) #创建单个元素的元组，要加一个逗号,否则由于()的分组功能重载，创建的是字符串

访问元素：tuple1[0]; tuple1[1:4]#

默认集合类型：

    ①所有多对象的，逗号分隔的，没有明确用符号定义的(像用方括号表示列表和用圆括号表示元组)，等等这  些集合默认的类型都是元组>>>'a','b','c'

    ②所有函数返回的多对象（不包括有符号封装的）都是元组类型

    ③建议总是显式的用圆括号表达式表示元组或者创建一个元组

2.3    字典{}

创建

dict1={'a':1,'b':2}

dict1=dict((('a',1),('b',2)))

dict1=dict((['a',1],['b',2]))

dict1=dict([('a',1),('b',2)])

dict1=dict([['a',1],['b',2]])

键是唯一的，初始化时输入同样的两键，自动替换第一个键

dict1={}.fromkeys(('x','y')[,-1])

{'x':-1,'y':-1} 若不指定值，则值为None

访问

val1=dict1['a']

'a'不可变。改变val1值时，创建新值，字典不变

val2=dict1.get('a'[,-1])

通过键获取值,若不存在，返回特定值

获取键值

dict1.keys()   dict1.values() dict1.items()

视图，dict_keys/dict_values/dict_items类型，不可改变值,用list()获取有序列表

遍历

for key in dict1:   for key, value in enumerate(dict1):

 

弹出

删除

dict1.pop(key)    dict1.popitems()

删除并返回对应键的值; 删除并返回键值对

del dict1['a']

 

dict.clear()

删除所有内容

添加

dict1['c']='z'

 

更新

dict1['a']='xxx'

 

dict1.update(dict0)

用字典dict0的键值对更新或添加到dict1中

比较

*cmp(dict1, dict2) python3去掉cmp()内置函数

（意义不大）比较顺序为：长度 -> 键 -> 值

拷贝

dict2=dict(dict1)    dict2=dict1.copy()

推荐用copy()函数，速度快。都是浅拷贝

字典中的键必须是可哈希的，所以数字和字符串可以作为字典中的键，但是列表和其他字典不行。

值相等的数字表示相同的键（1和1.0一样的键）。

2.4   集合

集合对象是一组无序排列的可哈希的值。

不包含重复值的数据集。分可变集合set()和不可变集合frozenset()。

创建：set1=set(['a','b','b','c','d']) #多余的'b'被删除

访问：①for item in set1：

      ②in ，not in

添加：①set1.add('a')

      ②set1.update('xyz')#添加'x','y','z'三个新元素

删除：①set1.remove('a')  ②set1.discard()#元素不存在不引发异常  ③set1.clear() ④set1.pop('x')

      ④set1-=set('xyz')#删除'x','y','z'三个元素

操作符(没有“+”)：

子集/超集(默认带=)

相等

交集

并集

差集

异或

无交集

更新集合

.issubset()

.issuperset()

 

.intersection()

.unin()

.difference()

symmetric_difference()

isdisjoint()

.XXXX_update()

<=   <

>=   >

==

|

&

-

^

 

|=

&=

-=

^=

可变/不可变集合混合运算，结果的类型与运算符左边的集合类型相同

2.5   内建函数

2.5.1   类型工厂函数

int();bool();float();complex();str()# 字符串和数值转换

list();tuple();dict();set();frozenset();

2.5.2   序列类内建函数

len();max();min();

sum(iterable  [,start]); #列表或可迭代对象

sorted() #返回完成排序的列表

zip(iterable1, iterable2,…) 

    zipped=list(zip([1,2],[3,4],[5,6]));#返回[(1,3,5),(2,4,6)]

    list(zip(*zipped))#返回[(1,2),(3,4),(5,6)]

enumerate(iterable):#返回迭代器,可以同时遍历索引和元素（迭代forindex,value in enumerate(iterable):）

reversed();#返回反序的迭代器

2.6   拷贝Python对象

浅拷贝：浅拷贝是Python对象的默认类型拷贝（以下操作，创建了新的对象引用，但是其元素的地址没有改变）

       ①完全切片操作[:]（或切片操作） ，②类型工厂函数list(),dict()等 ，③copy模块的copy函数

       非容器类型（数值、字符串等）没有被拷贝一说。若tuple的元素都是非容器类型，那么深拷贝也无法进     行（可能是考虑节约内存）

深拷贝：使用copy模块的deepcopy函数

拷贝对象的id、对象中第二个元素的id，是否与被拷贝对象相同

a=

[1,'x',3]

[1,('x'),3]

[1,['x'],3]

(1,['x'],3)

(1,'x',3)

(1,('x',),3)

'abcdefg'

a[:]

异

同

异

同

异

同

同

同

同

同

同

同

同

同

a[:2]

异

同

异

同

异

同

异

同

异

同

异

同

异

同

list[a]

异

同

异

同

异

同

异

同

异

同

异

同

异

同

copy(a)

异

同

异

同

异

同

同

同

同

同

同

同

同

同

deepcopy(a)

异

同

异

同

异

异

异

异

同

同

同

同

同

同

总结：

    创建和原来完全一样的浅拷贝，若对象本身是可变对象，则拷贝的引用是新的；

    创建和原来完全一样的浅拷贝，若对象本身是不可变对象，则拷贝的引用是不变的；

    创建对象的部分切片或转换为其他容器类型，获得一个新的引用，但是元素地址不变；

    创建的所有浅拷贝，无论元素是否是可变对象，元素地址是不变的；

    只有被拷贝的对象中有可变对象元素，才可以进行深拷贝。

2.7    is和 ==

is用于比较对象的标识，== 运算符比较两个对象的值（对象中保存的数据）。在变量和单例值之间比较时，应该使用 is。

x is None    x is not None