运算符

1、算数运算:

%:取模,可以用来算奇偶数

2、比较运算:

!=:不等于;<>也是,python3报错

3、赋值运算:

4、逻辑运算:

5、成员运算:

6、身份运算:

is:   type(a) is str

is not:type(a) is not list

基本数据类型

1、数字

int(整型)

  在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647

  在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807

2、布尔值

  真或假 || 1 或 0

3、字符串

字符串常用功能:

  • 移除空白:str = "  This is a string  \n"

    • str.strip()     #去除str前后的空格和换行,str == "This is a string"

    • str.strip('\n')   #仅去掉换行,str == "  This is a string  "

  • 分割:str = "alex,jack,rain"

    • str2 = str.split(',')  #被拆分成一list:['alex', 'jack', 'rain']

    • "|".join(str2)       #又被合成一string:'alex|jack|rain'

  • 长度:len(str)

  • 索引

    • "Hello,{name} is {what}".format(name='Q',what='IQ')

    • "Hello,{0} is {1}".formar('Q','IQ')

  • 切片:跟list列表一样

  • 判断

    • str.isdigit()#数字

    • str.isalnum()#不包含特殊字符

    • str.endswith('sth')

    • str.startswith('sth')

    • str.upper()   #变大写

    • str.lower()   #变小写

4、列表

创建列表:(其它语言叫数组,可以存储各种元素,包括变量,是个前闭后开区间)

name_list = ['alex','seven','eric']  或

name_list = list(['alex','seven','eric'])

基本操作:

  • 索引

    • name_list.insert(index,"sth")    #在index位置插入sth,一次只能插一个

  • 切片

    • name_list[::-1]        #倒序排列

  • 列表反转

    • name_list.reverse()    #跟倒序一样,只是直接保存在了原列表

  • 追加

    • name_list.append("last")  #在列表末尾追加last

  • 删除

    • name_list.remove("sth")   #删除列表的sth

    • name_list.pop(index)     #默认弹出最后一个,写几就弹几呗

    • del 是python的一个内置函数,可以删除任何东西

    • del name_list[1:2]       #删除列表第二个数

    • del name_list          #删除整个列表

  • 长度

    • len(name_list)

  • 排序

    • name_list.sort() #Python3不支持数字与字符串混排,单独可以,直接保存在name_list中

  • 列表扩展

    • name = [1,2,3]

    • name_list.extend(name) #将name追加到name_list中['alex','seven','eric',1,2,3]

  • 循环

    • in方法:name = [9,3,9,12,3,3,4,9,42,46,9,99,9]

if 9 in name:
  num_of = name.count(9)    #计算9的个数
  position_of = name.index(9) #只会输出第一个9的位置索引
  print(name_of,position_of)
#下面把9的内容都修改成110
for i in range(name.count(9)):
  name[name.index(9)] = 110
  • 列表的copy模块

    • list.copy()

>>>name = [1,2,3,[4,5,6]]

>>>name1 = name.copy()

>>>id(name),id(name1)  

(2129574779336, 2129574779144)  #俩内存地址是不同的

>>> name[3][0] = 444    #修改第二层列表,二者都会变

>>> name

[1, 2, 3, [444, 5, 6]]

>>> name1

[1, 2, 3, [444, 5, 6]]

>>> name[0] = 111      #修改第一层列表,则不会互相影响

>>> name

[111, 2, 3, [444, 5, 6]]

>>> name1

[1, 2, 3, [444, 5, 6]]

  • python默认只copy第一层列表,其它层列表只是指向其内存地址,so第一层列表是独立的,其它层列表都是共享的!!!

  • python有一个copy标准库,copy.copy()的效果跟list.copy()一样,然而copy.deepcopy()就是完全克隆过来!!两列表完全独立,不存在数据共享。

5、元祖(不可变列表)

 一般做统计使用

6、字典(无序且key值唯一)

sth = {

  110:{'name':'zhao','age':'12','tel':110},

  111:{'name':'qian','age':'15','tel':111},

  112:{'name':'sun','age':'11','tel':112}

}

删除值:

  用全局del或者sth.pop()均可

  del sth[110]['name']

  sth[110].pop('tel')

获取value值:

  如果key值存在,则以下两种获取方法均可;

     print(sth.get(110))

     print(sth[110])

  如果key值不存在,则sth.get()会返回None值,而sth[key]则会报错!!

更新字典:

  sth.update(dict2)  #用dict2的值来更新sth的值,如果key不存在则添加,存在则替换value值

  sth.items()      #需要先把字典转换成列表,耗时。。不用。。

  sth.keys()       #获取所有key

  sth.values()     #获取所有value

判断key是否在字典中:

  sth.has_key(110)#only in python 2.x

  110 in sth #python 3.x

print(sth.setdefault(113,"something"))

  #取一个key,如果存在则打印其value值,不存在则新增k,v值(value不写,默认为None)

print(dict.fromkeys([1,2,3],'allme'))

  #key不同,value值相同;据说这里面有一个坑,但是alex不说。。

print(sth.popitem())

  #随机删除,不要用

循环字典:

  for k,v in sth.items():

    print(k,v)          # 效率低,有一个dict to list的过程

==========================效率分割线=========================

  for key in sth:        # 效率高呀

    print(key,sth[key])

7、set集合(无序、不重复、可嵌套

s1 = {11, 22, 33} s2 = {22, 33} # s3 = s1.difference(s2)         #s1中存在,s2中不存在 # s1.difference_update(s2)    #会对s1进行更新 # s3 = s1.symmetric_difference(s2)         #对称差集,除了交集之外的元素 # s1.symmetric_difference_update(s2)    #会对s1进行更新 # s1.discard(11)  #移除指定元素,不存在不报错,最常用 # s1.remove(1111)  #移除指定元素,不存在报错 # ret = s1.pop()   #无参,随机移除(因为set也是无序的),返回删除元素 # s3 = s1.intersection(s2)        #取交集 # s1.intersection_update(s2)   #s1会被更新了 # s3 = s1.union(s2)          #取并集 # print(s2.issubset(s1))    #子集 # print(s1.issuperset(s2)) #父集 s1.add(56)              #add()只能每次添加一个元素 li = [66,77,88,99]    #列表是可迭代的 s1.update(li) # update()里接收可迭代【可被for循环】的元素即可(列表、元祖、字符串等)

发现一个东西:

    原来集合可以直接对字符串进行操作。。

>>> s1 = "thisisastring">>> s2 = set(s1)    # 直接set字符串>>> s2set(['a', 'g', 'i', 'h', 'n', 's', 'r', 't'])>>> s3 = list(s2)    # 将set转换成list再排序>>> s3['a', 'g', 'i', 'h', 'n', 's', 'r', 't']>>> s3.sort()>>> s3['a', 'g', 'h', 'i', 'n', 'r', 's', 't']>>> #########################################>>>      >>> s4 = list(s2)>>> s5 = s4.sort()    # list.sort()方法没有返回值,默认为None>>> s5>>>

小练习:(两个字典,原数据与最新收集的数据

old_dict = {

    "#1": 8,

    "#2": 4,

    "#4": 2

}

new_dict = {

    "#1": 4,

    "#2": 4,

    "#3": 2,

}

old_set = set(old_dict.keys())

new_set = set(new_dict.keys())

# 应该删除的槽位:old_dict存在而new_dict中不存在key

remove_set = old_set.difference(new_set)

#应该增加的槽位:new_dict存在而old_dict中不存在key

add_set = new_set.difference(old_set)

#应该更新的槽位

update_set = old_set.intersection(new_set)

其他

1、enumrate(枚举)

为可迭代的对象添加序号

li 
= 
[
11
,
22
,
33
]
for
 
k,v 
in
 
enumerate
(li, 
1
):    #后面那个1,是指序号从1开始计数
    
print
(k,v)

2、字体颜色

red_color = '\033[31;1m"sth_else"\033[0m'#字体颜色是红色

python中的单双引号没有区别