python第二次笔记2018.3.29

python变量

变量是计算机内存中的一块区域,变量可以存储规定范围内的值,而且值可以改变。

python下变量是对一个数据的引用

-变量的命名

-变量名由字母,数字,下划线组成

-变量不能以数字开头

-不可以使用关键字

-a a_1 _a

·变量的赋值

-是变量的声明喝定义的过程

a = 1

id(a)

运算符与表达式

python运算符包括

-赋值运算符

-算术运算符

-关系运算符

-逻辑运算符

·表达式是将不同的数据(包括变量、函数)用运算符号按一定规则连接起来的一种式子。

赋值运算符

=:x = 3,y = 'abcd'

+=:x += 2

-+:x -= 2

*=:x *= 2

/=:x /= 2

%=:x %= 2

算数运算符

+

-

*

/

// 整除,只取整数部分

%

**

关系运算符

>:1 > 2 大于

<:2 < 3 小于

>=:1 >= 1 大于等于

<=:2 <= 2 小于等于

==:2 == 2 等于

!=: 1 != 2 不等于

逻辑运算符

and逻辑与:true and false 同时成立返回true

or逻辑或: false or true 其中一个条件成立

not逻辑非:not true

In [94]: 1 == 1 and 2 == 2

Out[94]: True

In [95]: 1 == 1 and 2 == 3

Out[95]: False

In [96]: 1 == 1 or 2 == 3

Out[96]: True

In [97]: not 1 == 2

Out[97]: True

In [98]: not 1 == 1

Out[98]: False

Lambda

逻辑运算:or

逻辑运算:and

逻辑运算:not

成员测试:in ,not in

同一性测试:is ,is not

比较:<,<=,>,>=,!=,==

按位或:|

按位异或:^

按位与:&

移位:<<,>>

加法与减法:+,-

乘法,除法,取余:*,/,%

正负号:+x,-x

按位翻转:~x

指数:**

python数据类型

数值

字符串

列表

元组

字典

数据类型

整型

长整型

浮点型

复数型

type看属于什么类型

In [50]: tre

Out[50]: ['a', 1, 2, 3, ['hellow', 'python'], 1, 'linux', 'bbbbb']

In [51]: type(tre)

Out[51]: list

In [52]: a = 12222222222222222222222222222222

In [53]: a

Out[53]: 12222222222222222222222222222222L

In [54]: type(a)

Out[54]: long

a属于长整型

In [55]: 0x34al

Out[55]: 842L

0x是16进制的，转换成10进制就是842 （16进制，0-9 a-f）

浮点型

例如: 0.0 12.0 -18.8 3e+7

In [56]: a = 3e+7

In [57]: a

Out[57]: 30000000.0

In [58]: type(a)

Out[58]: float

字符串类型-string

有三种方法定义字符串类型

-str='this is string'

-str=''this is string''

-str='''this is string'''

三重引号(docstring)除了能定义字符串还可以用作注释。

In [59]: a = 'asfff'

In [60]: a

Out[60]: 'asfff'

In [61]: a[-1]

Out[61]: 'f'

In [62]: type(a)

Out[62]: str

这里的-1表示方向

元组:

len():求序列的长度

+:连续2个序列

*:重复序列的元素

in:判断元素是否在序列中

max():返回最大值

min():返回最小值

cmp(x,y):比较两个序列是否相等

元组()

元组和列表十分相似

元组和字符串一样是不可变的

元组可以存储一系列的值

元组通常用在用户定义的函数能够安全地采用一组值的时候,即被使用的元组的值不会改变

In [70]: t = ('a',1,(1,))

In [71]: t

Out[71]: ('a', 1, (1,))

In [72]: type(t)

Out[72]: tuple

In [73]: t[0]

Out[73]: 'a'

In [74]: t[0] = 1

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

TypeError Traceback (most recent call last)

<ipython-input-74-0a69537257d5> in <module>()

----> 1 t[0] = 1

TypeError: 'tuple' object does not support item assignment

不可变性

In [77]: a, b, c = t

In [78]: t

Out[78]: ('a', 1, (1,))

In [79]: a

Out[79]: 'a'

In [80]: b

Out[80]: 1

In [81]: c

Out[81]: (1,)

In [82]: type(a)

Out[82]: str

In [83]: type(b)

Out[83]: int

In [84]: type(c)

Out[84]: tuple

value通常表示元组里面的元素

In [85]: dir(t)

Out[85]:

['__add__',

'__class__',

'__contains__',

'__delattr__',

'__doc__',

'__eq__',

'__format__',

'__ge__',

'__getattribute__',

'__getitem__',

'__getnewargs__',

'__getslice__',

'__gt__',

'__hash__',

'__init__',

'__iter__',

'__le__',

'__len__',

'__lt__',

'__mul__',

'__ne__',

'__new__',

'__reduce__',

'__reduce_ex__',

'__repr__',

'__rmul__',

'__setattr__',

'__sizeof__',

'__str__',

'__subclasshook__',

'count',

'index']

列表

列表(list)是处理一组有序项目的数据结构,即可以在列表中存储一个系列的项目。

列表是可变类型的数据

创建列表

-list = []

-list2 = list()

-list3 = ['a',1,2]

In [86]: list = ['a',1,2,(3,'a',234)]

In [87]: list

Out[87]: ['a', 1, 2, (3, 'a', 234)]

In [88]: type(list)

Out[88]: list

In [89]: list2 = ['bvf','dsf','fv',213]

In [90]: list2 + list

Out[90]: ['bvf', 'dsf', 'fv', 213, 'a', 1, 2, (3, 'a', 234)]

append，在列表加入东西

In [91]: list2.append('linux')

In [92]: list2

Out[92]: ['bvf', 'dsf', 'fv', 213, 'linux']

•    List常用的方法：

•    append                              末尾增加一个元素，没有返回值

•    pop(index=none)                  末尾删除一个元素，返回删除的元素

•    Index                             l.index(“a”)    返回该元素的下标

•    insert               l.insert(3,“ling”)，插入指定的位置一个元素

•    remove(value)         l.remove(“hello”)，删除一个指定值的元素

•    reverse                   l.reverse()        反序，无返回值

•    sort(self, cmp=None, key=None, reverse=False)       l.sort()   排序

•    元组的常用方法

•    count          统计某个元素的个数

•    A = (‘a’, ‘b’, ‘c’, ‘a’)

•    print(A.count(‘a’))

•    index    返回某个元素的下标

•    和list类似

•    tuple并没法对元组进行增删改查

对象类型	例子   常量/创建
数字	1234,3.14123,3+4j,Decimal,Franction
字符串	'spam',"guido's",b'a\xolc'
列表	[1,[2,'three'],4]
字典	{'food':'spam','taste':'yum'}
元组	(1,'spam',4,'U')
文件	myfile=open('eggs','r')
集合	set('abc'),{'a','b','c'}
其他类型	类型,None,布尔型
编程单元类型	函数，模块，类
与显示相关的类型	编译的代码堆栈跟踪

# 总结：

# ""   字符串

# 字符串的方法：

# find() 查找

# replace()   替换

# strip()   前后去空格

# join(可迭代对象)      集成

# split()     分割

# format()    字符串格式化

 

# []   列表    list()

# 列表常用的方法

# append()    屁股后追加

# pop()    最后删除，返回值是删除的那个元素

# index(x)    返回元素的下标

# remove(x)     删除元素

# sort()      list排除

# reverse()     反序

# [:]    分片，前开后闭

# 下标元素从0开始

# ()   元组    tuple()

# "".     字符串的方法

# [].     列表的方法

# ().index(x)    ().count(x)

字典 {}

字典是python中唯一的映射类型(哈希表)

字典对象是可变的,但是字典的键必须使用不可变对象,一个字典中可以可以使用不同类型的键值。

字典的方法:

keys()

values()

items()