序列,目前看来很基础,东西比较多,难度开始加大。。。加油吧,骚年

Python之序列

1.数据结构:序列、容器(序列:索引、映射:键)、集合
2.列表、元组、字符串、Unicode字符串、buffer对象、xrange对象
3.列表可以修改、元组不可修改(一般情况下列表都可以替代元组),并且列表有许多专门方法(下面会说明)

序列

  1. #定义一个【名字、年龄】的库?datebase
  2. maomao=['maomao',21]
  3. chouchou=['chouchou',22]
  4. xiangxiang=['xiangxiang',23]
  5. benben=['benben',24]
  6. database=[maomao,chouchou,xiangxiang,benben]
  7. print database
  8. ------下面是结果
  9. [['maomao', 21], ['chouchou', 22], ['xiangxiang', 23], ['benben', 24]]

通用序列的操作:
索引、分片、加、乘、检查都元素是否属于序列成员、
计算序列长度、最大最小值、迭代(依次对序列中的每个元素重复执行X动作)

索引:
序列中的所有元素都是有编号的-----从0 开始递增。>>> greeting = 'maomao'

  1. >>> greeting[0]
  2. 'c'
  3. >>> greeting[2]
  4. 'o'

使用负数索引时,python 会从右边,也就是从最后1个元素开始计数。最后1个元素的位置编号是-1

  1. >>> greeting = 'maomao'
  2. >>> greeting[-1]
  3. 'o'
  4. >>> greeting[-2]
  5. 'a'

如果一个函数调用返回一个序列,那么可以直接对返回结果进行索引操作
例如,假设只对用户输入年份的第4个数字感兴趣,那么,可以进行如下操作:

  1. fourth = raw_input('year:')[3]
  2. print fourth
  3.  
  4. #以1-31的数字作为结尾的列表
  5. endings = ['st','nd','rd']+ 17*['th']\
  6. +['st','nd','rd']+ 7*['th']\
  7. +['st']
  1. #嗯,总的来说,目前对这一段代码,对目前的小白我内心还是崩溃的。。
  2.  
  3. #根据给定的年月日以数字形式打印出日期
  4. #定义months,是一个序列
  5. months = [
  6. 'January',
  7. 'February',
  8. 'March',
  9. 'April',
  10. 'May',
  11. 'June',
  12. 'July',
  13. 'August',
  14. 'September',
  15. 'October',
  16. 'November',
  17. 'December'
  18. ]
  19.  
  20. #以1-31的数字作为结尾的列表
  21. #['st','nd','rd']表示1/2/3日分别以'st','nd','rd'结束
  22. #17*['th']表示每月的第四日开始-第20日,均以'th'结束,为17个
  23. #['st','nd','rd']+ 7*['th']+['st'],就好理解了。。
  24. #每一行最后的\ 是用来换行的
  25. endings = ['st','nd','rd']+ 17*['th']\
  26. +['st','nd','rd']+ 7*['th']\
  27. +['st']
  28.  
  29. #python2中,要用raw_input语法来获取用户输入值,这玩意获取完大约是‘xx’--字符串类型?i am not sure??
  30. year =raw_input('year:')
  31. month =raw_input('month(1-12):')
  32. day =raw_input('day(1-31)')
  33.  
  34. #然后把获取到的用户输入的数值转换成int类型
  35. month_number = int(month)
  36. day_number = int(day)
  37.  
  38. #将月份和天数减1,以获得正确的索引,索引值是从0开始的
  39. month_name = months[month_number-1]
  40. ordinal = day + endings[day_number - 1]
  41.  
  42. print month_name + ' ,' + ordinal + ' ,' + year
  43. -----------------------------------------------
  44. 输入:
  45. >>>
  46. year:2017
  47. month(1-12):8
  48. day(1-31)3
  49. 输出:
  50. August ,3rd ,2017

    ------------------------------------
    (╥╯^╰╥)无奈呀~~加油吧,很快就能看懂了

-----------------华丽的分界线-------------

分片:类似java中的截取子串
(1)基础分片
格式:变量[x:y]---第x个索引开始,第y-1个索引结束,分片通过冒号相隔的两个索引来实现

  1. >>> tag = '<a href="http://www.python.org">Python web site</a>'
  2. >>> tag[9:30] # 取第9个到第30个之间的字符
  3. 'http://www.python.org'
  4. >>> tag[32:-4] #取第32到第-4(倒着数第4个字符)
  5. 'Python web site'
  6. >>>
  1. >>> numbers = [0,1,2,3,4,5,6,7,8,9]
  2. >>> numbers[7:-1] # 从第7个数到 倒数第一个数
  3. [7, 8] #显然这样不可行
  4. >>> numbers[7:10] #从第7个数到第10个数
  5. [7, 8, 9] #这样可行,索引10指向的是第11个元素。
  6. >>> numbers[7:] # 可以置空最后一个索引解决
  7. [7, 8, 9]
  8. >>> numbers[:3]
  9. [0, 1, 2]
  10. >>> numbers[:]
  11. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  1. url = raw_input('Please enter the URL:')
  2. domain = url[11:-4]
  3.  
  4. print "Domain name:" + domain
  5. ------------------------------------------
  6. 输入:
  7. >>>
  8. Please enter the URL:http://fnng.cngblogs.com
  9. 输出:
  10. Domain name:.cngblogs

(2)进阶分片
分片可以正分片,也可以负分片
正分片:头到尾
格式:变量[x:y:z] 要求x<y,且z>0
表示第x个索引开始,第y-1个索引结束,并以z-1为分片步数---第x个索引开始,第y-1个索引结束,并以z-1为分片步数(即:每z个字符取一个)
负分片:尾到头
格式:变量[x:y:z] 要求x>y,且z<0
表示第x个索引开始,第y-1个索引结束,并以z-1为分片步数---第x个索引开始,第y-1个索引结束,并以z-1为分片步数(即:每z个字符取一个)
该方法实现序列的倒输出
当x/y没有指定固定值时,如步数为正,则自左向右按步数取值
如步数为负,则自右向左按步数取值

  1. 正分片:
  2. numbers = [0,1,2,3,4,5,6,7,8,9]
  3. print numbers[0:1] #[0]
  4. print numbers[:] #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  5. print numbers[0:] #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  6. print numbers[:10] #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  7. print numbers[3:7] #[3, 4, 5, 6]
  8. print numbers[0:10:2] #[0, 2, 4, 6, 8]
  9. print numbers[3:6:3] #[3]
  1. 负分片
  2. print numbers[::4] #[0, 4, 8]
  3. print numbers[8:3:-1] #[8, 7, 6, 5, 4]
  4. print numbers[10:0:-2] #[9, 7, 5, 3, 1]
  5. print numbers[::-2] #[9, 7, 5, 3, 1]
  6. print numbers[5::-2] #[5, 3, 1]
  7. print numbers[:5:-2] #[9, 7]

-----------------华丽的分界线-------------

序列相加:
通过使用加号可以进行序列的连接操作:+
列表和字符串是无法连接接在一起的,尽管它他们都是序列。简单来说,两种相同类型的序列才能进行连接操作。

  1. >>> 'hello.'+'world!'
  2. 'hello.world!'
  3.  
  4. >>> [1,2,3]+[4,5,6]
  5. [1,2,3,4,5,6]
  6.  
  7. >>> [1,2,3] + 'world!'
  8. Traceback (most recent call last):
  9. File "<pyshell#20>", line 1, in <module>
  10. [1,2,3] + 'world!'
  11. TypeError: can only concatenate list (not "str") to list

乘法:
序列*次数,生成新的序列,原序列执行次数次

  1. print 'python'*5 #pythonpythonpythonpythonpython
  2. print [42]*5 #[42, 42, 42, 42, 42]
  3. print [42,32]*5 #[42, 32, 42, 32, 42, 32, 42, 32, 42, 32]

如果想创建一个占用十个元素空间,却不包括任何有用的内容的列表,可以用None

  1. print []*5 #[] 为空序列
  2. print [0]*5 #[0, 0, 0, 0, 0] 为没有任何意义的序列
  3. print [None]*5 #[None, None, None, None, None] 为有None站位符的序列

---神一样的盒子

  1. # 以正确的宽度在居中的“盒子”内打印一个句子
  2. sentence = raw_input("Sentence : ")
  3.  
  4. screen_width = 80
  5. text_width = len(sentence)
  6. box_width = text_width + 6
  7. left_margin = (screen_width - box_width) //2
  8.  
  9. print
  10. print ' ' * left_margin + '+' + '-' * (box_width - 2)+ '+'
  11. print ' ' * left_margin + '| ' + ' ' * text_width + ' |'
  12. print ' ' * left_margin + '| ' + sentence + ' |'
  13. print ' ' * left_margin + '| ' + ' ' * text_width + ' |'
  14. print ' ' * left_margin + '+' + '-' * (box_width - 2)+ '+'

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

想看输入结果不。。。嗯,自己抄代码去。。。

绝对不会承认是偶copy不出效果来了。(⊙▽⊙)

-----------------华丽的分界线-------------
成员资格:

为了检查一个值是否在序列中,可以使用in 运算符。该运算符和之前已经讨论过的(例如 + , * 运算符)有一点不同。
这个运算符检查某个条件为真或假的(True or False )。

  1. >>> permissions = 'rw' #可用于检查文件处理权限
  2. >>> 'w' in permissions
  3. True
  4. >>> 'y' in permissions
  5. False
  6. >>> users = ['zhangsan', 'lisi','wangwu'] #可用于检查用户是否在列表中
  7. >>> raw_input('Enter your user name: ') in users
  8. Enter your user name: lisi
  9. True
  10. >>> subject ='$$$ Get rich now!!! $$$' #可用于垃圾邮件的过滤器一部分
  11. >>> '$$$' in subject

-----------------华丽的分界线-------------

长度、最值
函数:
len() 返回序列中所包含元素的数量。
min() 返回序列中最小的元素。
max() 返回序列中最大元素。

  1. #开始用eclipse写代码,与ubantu的交互设计不一致
  2. -----输入
  3. number = [100,23,233,455]
  4. print len(number) #获取长度
  5. print min(number) #最小值
  6. print max(number) #最大值
  7.  
  8. print max(2,3) #最大值
  9. print min(2,3,5,3,6,7,82,) #最小值
  10.  
  11. ------输出
  12. 4
  13. 23
  14. 455
  15.  
  16. 3
  17. 2

--------------------------------分界线---------------------------

列表的函数方法们
列表是可变的,所有就有各种增删改查的方法
list() 用于将所有数据类型序列拆分成列表
join(somelist) 用于将列表转换成字符串

----元素赋值
----元素删除
----分片赋值
----列表方法
上述四方法并不都真正的改变列表

---元素赋值方法

  1. 方法一:定义列表是赋值,之前已经讲过,如
  2. listA = [1,3,5,7,9]
    方法二:利用索引,重新对列表重点元素进行赋值
  3. listB = [1,1,1]
  4. listB[1]=2 #注意,利用索引进行赋值时,不能超过该序列的索引长度,否则会索引越界
  5. print listB #[1,2,1]

---元素删除方法:del():用于删除列表、字典、及其他元素。此处暂只说明列表元素的说明

  1. #del():

name = ['maomao','chouchou','guodong','benben']
del name[0]
print name
print len(name)
---
['chouchou', 'guodong', 'benben']
3

  1.  

----分片赋值方法
可以用来替换、插入、删除

  1. name = list('maomao') #把maomao用list()转换成列表
  2. print name
  3. name[3:] = list('ben') #从第三个元素开始到结束,用list()转换成的ben来替代
  4. print name
  5. ----
  6. ['m', 'a', 'o', 'm', 'a', 'o']
  7. ['m', 'a', 'o', 'b', 'e', 'n']
  8.  
  9. name = list('maomao')
  10. name[3:] = list('xihuanben') #从第三个元素开始到结束,用list()转换成的xihuanben来替代
  11. print name
  12. ----
  13. ['m', 'a', 'o', 'x', 'i', 'h', 'u', 'a', 'n', 'b', 'e', 'n']
  14.  
  15. name = list('maomao')
  16. name[0:0] = list('da') #从第0个元素开始到第0-1个元素结束(即为[]字符),用list()转换成的da来插入
  17. print name
  18. ----
  19. ['d', 'a', 'm', 'a', 'o', 'm', 'a', 'o']
  20.  
  21. number = [1,5]
  22. number[1:1] = [2,3,4] #从第1个元素开始到第1-1个元素结束,用2,3,4来插入
  23. print number
  24. ----
  25. [1, 2, 3, 4, 5]
  26.  
  27. number = [4,5]
  28. number[0:0] = [1,2,3] #从第0个元素开始到第0-1个元素,用1,2,3来插入
  29. print number
  30. ----
  31. [1, 2, 3, 4, 5]
  32.  
  33. number = [1,2,3,4,5]
  34. number[1:4] = [] #从第1个元素开始到第4-1个元素,用[]来替换,实则为删除第2-4个数字
  35. print number
  36. ----
  37. [1, 5]

嗯。。。今天有个巨大的遗留问题就是:分片+step  或者  分片+负数step 的替换、删除、插入怎么玩 ???

揪心啊 ヽ(`Д´)ノ︵ ┻━┻ ┻━┻

٩(๑❛ᴗ❛๑)۶今儿先到这。。helloha~

小白之Python-基础中的基础03的更多相关文章

  1. [.net 面向对象编程基础] (3) 基础中的基础——数据类型

    [.net 面向对象编程基础] (3) 基础中的基础——数据类型 关于数据类型,这是基础中的基础. 基础..基础..基础.基本功必须要扎实. 首先,从使用电脑开始,再到编程,电脑要存储数据,就要按类型 ...

  2. [.net 面向对象编程基础] (4) 基础中的基础——数据类型转换

    [.net面向对象编程基础] (4)基础中的基础——数据类型转换 1.为什么要进行数据转换? 首先,为什么要进行数据转换,拿值类型例子说明一下, 比如:我们要把23角零钱,换成2.30元,就需要把整形 ...

  3. [.net 面向对象编程基础] (5) 基础中的基础——变量和常量

    [.net面向对象编程基础]  (5) 基础中的基础——变量和常量 1.常量:在编译时其值能够确定,并且程序运行过程中值不发生变化的量. 通俗来说,就是定义一个不能改变值的量.既然不能变动值,那就必须 ...

  4. [.net 面向对象编程基础] (6) 基础中的基础——运算符和表达式

    [.net 面向对象编程基础] (6) 基础中的基础——运算符和表达式 说起C#运算符和表达式,小伙伴们肯定以为很简单,其实要用好表达式,不是一件容易的事.一个好的表达式可以让你做事半功倍的效果,比如 ...

  5. [.net 面向对象编程基础] (7) 基础中的基础——流程控制语句

    [.net 面向对象编程基础] (7) 基础中的基础——流程控制语句 本来没有这一节的内容,后来考虑到既然是一个系列文章,那么就尽可能写的详细一些,本节参考了网上朋友所写的例子,为的是让更多小伙伴学习 ...

  6. [.net 面向对象编程基础] (8) 基础中的基础——修饰符

    [.net 面向对象编程基础] (8) 基础中的基础——修饰符 在进入C#面向对象核心之前,我们需要先对修饰符有所了解,其实我们在前面说到变量和常量的时候,已经使用了修饰符,并且说明了变量和常量的修改 ...

  7. 从头开始学JavaScript 笔记(一)——基础中的基础

    原文:从头开始学JavaScript 笔记(一)--基础中的基础 概要:javascript的组成. 各个组成部分的作用 . 一.javascript的组成   javascript   ECMASc ...

  8. C++ 基础中的基础 ---- 引用

    C++ 基础中的基础 ---- 引用 引用的概念:引用变量是一个别名,也就是说,它是某个已存在变量的另一个名字.一旦把引用初始化为某个变量,就可以使用该引用名称或变量名称来指向变量.比如: int n ...

  9. python之基础中的基础(一)

    python是一个效率极高的语言,现在市面上的机器学习大部分是由python和R语言完成,所以在不久之前小仙心中便种下了学习python的想法.下面是这一个月多月以来学习的总结,都是基础中基础了. 1 ...

  10. 【Python】编程小白的第一本python(基础中的基础)

    一.变量 如果不知道变量是什么类型,可以通过type()函数来查看类型,在IDE中输入: print(type(word)) 另外,由于中文注释会导致报错,所以需要在文件开头加一行魔法注释 #codi ...

随机推荐

  1. rust 模块、路径、项目类型等相关内容

    rust 模块路径 转载 https://blog.csdn.net/wowotuo/article/details/107591501 rust 项目编译类型 转载 https://blog.51c ...

  2. SpringBoot 学习 step.3数据库

    数据库 JPA默认用的是Hibernate. SpringBoot开发WEB应用时,目前菜用较多的是mybatis+mybatis-plus,还有是springboot-data-jpa,jpa默认使 ...

  3. IDEA插件:lombok

    1 安装插件lombok File => Settings => Plugins => Marketplace.在 Marketplace 中搜索 lombok 并安装,安装成功后 ...

  4. Python装饰器实例讲解(三)

    Python装饰器实例讲解(三) 本文多参考<流畅的python>,在此基础上增加了一些实例便于理解 姊妹篇 Python装饰器实例讲解(一),让你简单的会用 Python装饰器实例讲解( ...

  5. Spring IOC官方文档学习笔记(十一)之使用JSR 330标准注解

    1.使用@Inject和@Named进行依赖注入 (1) Spring提供了对JSR 330标准注解的支持,因此我们也可以使用JSR 330标准注解来进行依赖注入,不过,在此之前,我们得先使用mave ...

  6. ideal的基础使用2022版本,黑马程序员的基础使用

    1. 2.配xml <dependencies>    <dependency>        <groupId>javax.servlet</groupId ...

  7. 原生微信小程序的一些注意点

    1.微信小程序的数据更新 Page({ // 响应式的数据定义在data里面 data: { bannerList: [] }, // 微信小程序的数据更新是在setData里面做的 this.set ...

  8. 一篇文章让你了解这个基于树莓派而设计的工业计算机-CM4 Industrial

    CM4 Industrial是一款基于 Raspberry Pi / 树莓派 Compute Module 4,由EDATEC面向工业应用设计的嵌入式计算机设计的工业嵌入式计算机.系统可以根据不同的应 ...

  9. KMP 算法(Knuth–Morris–Pratt algorithm)的基本思想

    KMP 算法(Knuth–Morris–Pratt algorithm)的基本思想 阅读本文之前,您最好能够了解 KMP 算法解决的是什么问题,最好能用暴力方式(Brute Force)解决一下该问题 ...

  10. Cesium计算范围(十三)

    function bounds(positions = [], expand = 0) { let minLng = 180 let minLat = 90 let maxLng = -180 let ...