【美洲杯赌球】2018.7.7 第一周知识点总结

第一周总结:

Python第三天 序列  5种数据类型  数值  字符串  列表  元组  字典

 

目录

Pycharm使用技巧(转载)

Python第一天  安装  shell  文件

Python第二天  变量  运算符与表达式  input()与raw_input()区别  字符编码  python转义符  字符串格式化

Python第三天 序列  5种数据类型  数值  字符串  列表  元组  字典

Python第四天   流程控制   if else条件判断   for循环 while循环

Python第五天   文件访问    for循环访问文件    while循环访问文件   字符串的startswith函数和split函数

Python第六天   类型转换

Python第七天   函数  函数参数   函数变量   函数返回值  多类型传值    冗余参数   函数递归调用   匿名函数   内置函数   列表表达式/列表重写

Python第八天  模块   包   全局变量和内置变量__name__    Python path

Python第九天  面向对象  类定义   类的属性    类的方法    内部类   垃圾回收机制   类的继承 装饰器

Python第十天   print >> f,和fd.write()的区别    stdout的buffer  标准输入 标准输出  标准错误   重定向 输出流和输入流

Python第十一天    异常处理  glob模块和shlex模块    打开外部程序和subprocess模块  subprocess类  Pipe管道  operator模块   sorted函数   生成器  walk模块   hashlib模块

Python第十二天     收集主机信息     正则表达式  无名分组   有名分组

Python第十三天   django 1.6   导入模板   定义数据模型   访问数据库   GET和POST方法    SimpleCMDB项目   urllib模块   urllib2模块  httplib模块  django和web服务器整合  wsgi模块   gunicorn模块

Python第十四天 序列化  pickle模块  cPickle模块  JSON模块  API的两种格式

Python第十五天  datetime模块 time模块   thread模块  threading模块  Queue队列模块  multiprocessing模块  paramiko模块  fabric模块  

 

 

 

 

5种数据类型
数值
字符串 (序列)
列表(序列)
元组(序列)
字典(可迭代对象)

 

 

序列
序列:字符串、列表、元组
序列的两个主要特点是索引操作符切片操作符

  • 索引操作符让我们可以从序列中抓取一个特定项目
  • 切片操作符让我们能够获取序列的一个切片,即一部分序列

序列的基本操作

  1. len(): 求序列的长度
  2. : 连接2个序列
  3. *: 重复序列元素
  4. in/not in: 判断元素是否在序列中
  5. max(): 返回最大值
  6. min(): 返回最小值
  7. cmp(x, y):比较两个序列是否相等 返回值大于0 ,等于0,小于0
    cmp:按照字符串比较,字符串比较的原则就是一个字符一个字符的比较,字符按照ASCII码来比较,字符1比字符2小,所以gene1001小于gene2。

 


数值类型

  • 整型  2^32个数字,范围-2,147,483,648到2147483647
  • 长整型  区分普通整型,需要在整数后加L或l。2345L,0x34al
  • 浮点型  0.0,12.0,-18.8,3e 7
  • 复数型  - 3.14j,8.32e-36j

字符串''类型

字符串是不可变数据类型
有三种方法定义字符串类型
str = 'this is a string'
str = "this is a string"
str = '''this is a string'''  或 """this is a string"""
三重引号(docstring)除了能定义字符串还可以用作注释
python里面单引号和双引号没有任何区别

n:换行
str = "this is a nstring"

字符串索引
字符串是序列,可以通过索引取每个字符
加号 :字符串连接符
str = 'abcde'
str[0] str[1]
字符串切片
str[start:end:step]
step:为负数表示从右向左,步长为正数,start那个数字的值不要,步长为负数,end那个数字的值不要

>>> str[1:3]
'bc'
>>> str[:3]
'abc'
>>> str[3:]
'de'
>>> str[::1]
'abcde'
>>> str[::2]
'ace'
>>> str[-1]
'e'
>>> str[-4:-1]
'bcd'
>>> str[-2:-4:-1]
'dc'

字符串相关函数
replace()
split()
join()
strip()
format()  :'{0},I'm {1},my E-mail is {2}'.format('Hello','Hongten','hongtenzone@foxmail.com')
find()


元组()类型
元组和列表十分相似
元组和字符串一样是不可变的,不可变的意思是元组里面的元素不能修改,比如a[-1] = xx 会报错

  一. python基础

- 元组可以存储一系列的值

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

创建元组
t= ()
t= (2,) 一定要加逗号才是元组,否则会当普通字符串对待
t = ('james', 'M')
t = ('james', 'M',(1,)) 元组里面包含元组
j = 'sd'
t = (j, 'M') 包含变量

print t
('sd', 'M')

print t[0] 返回第一个元素

 

元组操作

  • 元组和字符串一样属于序列类型,可以通过索引和切片操作
  • 元组值不可变
    元组的拆分

    t = (1,2,3) a, b, c = t a 1 b 2 c 3

 

 

M=2
t = ('james', M,'gg','cc')
for a in t:
    print a
james
2
gg
cc

 

 b=('a','b','a','d','a')
print(b.count('a'))  统计'a'这个元素一共有多少个


列表[]类型

列表(list)是处理一组有序项目的数据结构,即可以在列表中存储一个序列的项目。
列表是可变类型的数据类型
创建列表
list1 = []
list2 = list()   list()函数
list3 = ['a',1,2]
list4 = ['a',1,(1,),['sdf','sww]]

对某项目赋值,下标从0开始
list3[0] = 'b'

列表操作

  • 取值
    切片和索引

    切片 l = list(range(10)) l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] l[5:0:-1] 输出:[5, 4, 3, 2, 1] l[5:4:-1] 输出:[5] l[:3:-1] 输出:[9, 8, 7, 6, 5, 4] l[0:3:-1] 输出:[] l[9::-1] 输出:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0] l[-2:]( l[-2:10:1]) 输出:[8, 9] l[2:]( l[2:10:1]) 输出:[2, 3, 4, 5, 6, 7, 8, 9] l[:-2]( l[0:-2:1]) 输出:[0, 1, 2, 3, 4, 5, 6, 7] l[0] 输出:0

    l[列表最小值:列表最大值:步进] 步长为正数情况下输出不包含列表最大值 列表最小值下标从0开始 -1:9 -2:8

- 添加
list.append()
list1[2].append('abc')  如果列表里面又有列表使用下标来访问
添加 list= list [6]  ,list2 =[1,2]   list = list list2

  • 删除
    del list[x] 删除某个元素  del list 删除整个列表
    list.remove(列表里面实际的值)
  • 修改
    list[] = x
  • 查找
    var in list
  • 插入
    list.insert(list[x],object)  在下标前插入一个对象
  • 排序
    list.sort()
  • 反转
    list.reverse()
  • 弹出
    list.pop([index])  返回一个元素并删除这个元素,参数是下标,没有参数会删除最后一个元素
  • 扩展
    list.extend(iterable)  可迭代的,相比append()方法可以追加多个值,l.extend(range(10))
  • 统计
    a = ['s','c','c']
    a.count('c')  统计'c'这个元素一共有多少个

 

https://www.cnblogs.com/meitian/p/4649173.html

Python合并列表,append()、extend()、 、 =
1.append() 向列表尾部追加一个新元素,列表只占一个索引位,在原有列表上增加
2.extend() 向列表尾部追加一个列表,将列表中的每个元素都追加进来,在原有列表上增加
3. 直接用 号看上去与用extend()一样的效果,但是实际上是生成了一个新的列表存这两个列表的和,只能用在两个列表相加上
4. = 效果与extend()一样,向原列表追加一个新元素,在原有列表上增加

美洲杯赌球 1


 

字典{}类型

字典是python中的唯一的映射类型(哈希表)
字典对象是可变的,但是字典的键必须使用不可变对象,一个字典中可以使用不同类型的键值。
跟redis的set类型一样,字典里的key不能重复,赋值的时候如果发现已有key则替换
字典的方法:

  • keys() 返回所有key
  • values() 返回所有value
  • items() 返回一个列表,key和value在一个元组里

创建字典
dic = {}
dic = dict()

dict()函数
help(dict)

 

字典创建
第一种
dict(([美洲杯赌球,'a',1],['b',2]))  #dict()函数方式1
aa=dict((['a',1],['b',2]))
print aa
{'a': 1, 'b': 2}

第二种
dict(a=1, b=2)  #dict()函数方式2
bb=dict(a=1, b=2)
print bb
{'a': 1, 'b': 2}

第三种
dd = {'line':1,'char':2,'word':3} 或dd = {1:1,2:2,3:3} 
print dd

{'char': 2, 'line': 1, 'word': 3}

第四种
info = {}  #创建一个空字典
info['name'] = 'name'
info['age'] = 'age'
info['gender'] = 'gender'
print info
{'gender': 'gender', 'age': 'age', 'name': 'name'}

 

 

fromkeys()函数
fromkeys(S[,v]) S指定一个序列,v指定value的值,默认为None。
dic.fromkeys(range(3),100)
In [4]: dic.fromkeys(range(3),100)
Out[4]: {0: 100, 1: 100, 2: 100}
fromkeys函数创建的字典需要赋值到另一个字典才能保存
ddict = {}.fromkeys(('x','y'), 100)

 

update()函数
将一个字典添加到另一个字典
dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }

dict1.update(dict2)
print "dict1 : %s" %  dict1

 

get()函数
将代入key,返回value
dict1 = {'Name': 'Zara', 'Age': 7}
dict1.get('Age')
print "dict1 : %s" %  dict1  返回7

 

pop函数  删除字典里某个key值
dict1 = {'Name': 'Zara', 'Age': 7}
dict1.pop('Age')
print dict1

 

zip函数 dict函数 接受任意多个(包括0个和1个)序列作为参数,返回一个tuple列表
x = [1, 2, 3]
y = ['a', 'b', 'c']
xyz = zip(x, y,)
print xyz
print dict(xyz)

 

访问字典
直接使用key访问:key不存在会报错,可以使用has_key()或者in和not in判断。
循环遍历  items()  ,iteritems()函数
例:
for i in dic.keys():
for i in dic:
print i 读取的是key
print dic[i] 读取的是value

for i, o in dic.items():
    print i, o

建议使用iteritems函数,items函数会一次性把字典的所有键值全部取出来,而iteritems函数只会一次取出一个

dict1 = {'Name': 'Zara', 'Age': 7}
for i, o in dict1.iteritems():
    print i, o

 

 

 

#!/usr/bin/python

info = {}  创建一个空字典
name = raw_input("Please input name: ")
age = raw_input("Please input age: ")
gender = raw_input('Please input (M/F): ')
info['name'] = name
info['age'] = age
info['gender'] = gender
for k, v in info.items():
print "%s: %s" % (k, v)
print 'main end'

 

 

容器(container)
容器是一种把多个元素组织在一起的数据结构,容器中的元素可以逐个地迭代获取,可以用 in , not in 关键字判断元素是否包含在容器中。通常这类数据结构把所有的元素存储在内存中(也有一些特列并不是所有的元素都放在内存)在Python中,常见的容器对象有:

list, deque, ....
set, frozensets, ....
dict, defaultdict, OrderedDict, Counter, ....
tuple, namedtuple, …
str


可迭代对象(iterable)
刚才说过,很多容器都是可迭代对象,此外还有更多的对象同样也是可迭代对象,比如处于打开状态的files,sockets等等。
但凡是可以返回一个 迭代器 的对象都可称之为可迭代对象


什么是迭代器呢?
它是一个带状态的对象,他能在你调用 next() 方法的时候返回容器中的下一个值,任何实现了 __next__() (python2中实现 next() )方法的对象都是迭代器


序列:字符串、列表、元组
序列跟迭代器不一样,序列对象没有next()方法


生成器(generator)
生成器算得上是Python语言中最吸引人的特性之一,生成器其实是一种特殊的迭代器,不过这种迭代器更加优雅。
它不需要再像上面的类一样写 __iter__() 和 __next__() 方法了,只需要一个 yiled 关键字。 因此任何生成器也是以一种懒加载的模式生成值。,因此任何生成器也是以一种懒加载的模式生成值。

例如数据库的全局唯一ID生成器,也是一种生成器


生成器是迭代器,但是迭代器不一定是生成器,因为生成器是有状态的!!!!!!

 

    1. python 是一门解释型,弱类型语言.

    2. print('内容', '内容' , end = 'n')    #  print() 打印时,后面end默认是(n)换行.  若不想换行则需要给end进行赋值

    3. 变量: 程序运算过程中产生的中间值,存储在内存中.供后面的程序调用.

    4. 变量的数据类型(现阶段学习的类型):

      1) int     整数类型

      2) str     字符串类型

      3)bool   布尔类型,值只有True和false

    5. 命名规则:

      1) 由数字,字母,下划线组成

      2) 不能是纯数字,或者数字开头

      3)不能是关键字

      4)不能太长

      5)要有意义

      6)不要用中文

      7)区分大小写

      8)推荐使用驼峰和下划线的方法命名

  6. input()   用户输入    #与用户进行交互,当程序运行到这里时,暂停等待用户输入内容让后再继续运行程序.

  7. if 判断:

    if 条件:          if 条件:

      代码块          代码块1

    else:           elif 条件2:

      代码块          代码块2

                 ......

                 else:

                  

二. while循环:

  1.while的基本样式:

    while 条件:

      循环体        #  流程:  判断条件是否为真,为真时,执行循环体,再次判断是否为真......

    else:            指导判断结果为假时,执行else,退出循环.

      代码块

  2.格式化输出:

    1) %s 字符串    例:  a = '我爱我家,我爱%s,我爱%s!'  % ('XX' , 'nn')  print(a)=====>   我爱我家,我爱XX,我爱nn!

    2) %d 数字  例:  a = '在北京有%d家五星级酒店,%d家商务酒店.'  % (22,66)  print(a)  ====>   在北京有22家五

               星级酒店,66家商务酒店.

  3.运算符:

    1.逻辑运算:

      1) end     与     两端同时为真的时候结果为真,否则为假.

      2) or      或者   两端有一个为真结果就为真,只有两端同时为假时,结果才为假.

      3) not    取反  

      运算顺序:    () => not => and => or =>最后才是< 和 > 

      x or y  ===>   如果X非零, 取X.    否则取y

  2.编码种类:

    1.  ASCII,    8bit ,       1byte

    2.  GBK,    16bit ,       2byte

    3.  UTF - 8,    英文  8bit   1byte      欧洲    16bit    2byte    中国     32bit     3byte

  3. 基本的数据类型:

    1. 基本的数据类型:

      1). int  数字,  bit_length()  二进制长度

      2). bool  空: False      非空: True

      3). str  字符串不可变

        字符串的基本操作方法:

          1. 索引切片:   由 0 开始   #即可以从字符串里的第一项开始,即0位置.

            方法:   [起始位置 : 结束位置 : 步长]

          2. 操作:

            1). upper()  变成大写       一般用于忽略大小写的时候,或者有大小写歧义的时候.

               例:    

                a = 'abcd'        a.upper()       print(a)  ======>    ABCD

            2).strip()  去掉空格(两端的)

               例:

                a = '     abcd      '       a.strip()       print(a)   =====>  "abcd"

            3).split()  切割

               例:

                a = 'a, b, c, d'  a.split(" , ")  print(a)   ====>  'a'  'b'  'c'  'd'

            4). replace()  替换     

               例:   a = 'a a a a a a a a a '

                 b = a.replace('a' , 'b')

                                   b = a.replace('a', 'b' , 3)

                    print(b) ==>  'b b b b b b b b b'    print(b) ==>   'b b b a a a a a a '  

            5). startswith()  以XXX开头

              a = 'abcd'       a.startswith('a')  ==>   Ture         a.startswith('b) ===> False       如果是以XX开头则返回Ture否则返回False.

            6). find()  找出XXX字符串在原字符串中出现的次数,找不到返回 -1

              a = 'abcd'     print(a.find('a'))===>    1

本文由美洲杯赌球发布于计算机教程,转载请注明出处:【美洲杯赌球】2018.7.7 第一周知识点总结

TAG标签: 美洲杯赌球
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。