Python 是一种跨平台的计算机程序设计语言，是一种面向对象的动态类型语言，笔记内容包括编译安装python，python列表，字典，元组，文件操作等命令的基本使用技巧。

◆编译安装 Python◆

Python的开发环境安装和配置非常的简单,如果是Linux系统则会默认集成安装了Python环境,Python的可执行文件被放在了/usr/local/bin目录下,库函数被安装在了/usr/local/python 目录中,由于二进制安装非常简单,故此处将使用源码的方式来编译安装Python解释器.

1.首先安装gcc编译器,和编译Python所需要使用的相关依赖包.

[root@localhost ~]# yum -y install gcc zlib zlib-devel openssl openssl-devel libffi-devel wget Package gcc-4.8.5-36.el7.x86_64 already installed and latest version
Package zlib-1.2.7-18.el7.x86_64 already installed and latest version
Package zlib-devel-1.2.7-18.el7.x86_64 already installed and latest version
Package openssl-1.0.2k-16.el7.x86_64 already installed and latest version
Package openssl-devel-1.0.2k-16.el7.x86_64 already installed and latest version
Package libffi-devel-3.0.13-18.el7.x86_64 already installed and latest version
Nothing to do 

2.下载Python源代码,然后依次执行nmake命令完成整个编译过程,等待时间较长这里直接略过.

[root@localhost ~]# yum install -y readline [root@localhost ~]# wget https://www.python.org/ftp/python/3.8.0/Python-3.8.0.tgz [root@localhost ~]# tar -xzvf Python-3.8.0.tgz -C /usr/src/ [root@localhost ~]# cd /usr/src/Python-3.8.0/ [root@localhost ~]# ./configure --prefix=/usr/local/python3 [root@localhost ~]# make && make altinstall 

3.将Python的头文件拷贝到系统标准目录下,避免直接使用Python时找不到所需的头文件.

[root@localhost ~]# cd /usr/local/python3/include/python3.8 [root@localhost ~]# cp -a ./* /usr/local/include/ 

4.接着我们备份一下旧版本的Python,并创建符号链接链接到新版本的Python上面.

[root@localhost ~]# cd /usr/bin/ [root@localhost bin]# mv python python.old [root@localhost bin]# ln -s /usr/local/python3/bin/python3.8 /usr/local/bin/python [root@localhost bin]# cp -a /usr/local/python3/bin/python3.8 /usr/bin/python 

5.由于YUM仓库是用Python开发,这里为了避免Python2与Python3之间冲突需替换一下.

[root@localhost ~]# vim /usr/bin/yum #!/usr/bin/python2.7       ←此处将python改成python2.7 [root@localhost ~]# vim /usr/libexec/urlgrabber-ext-down #!/usr/bin/python2.7       ←此处将python改成python2.7 

6.最后测试Python新版本是否生效,然后再使用YUM命令看是否有效,我这里一切正常.

[root@localhost bin]# python Python 3.8.0 (default, Nov  9 2019, 01:48:59) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-39)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()

7.安装pip包管理工具,该工具提供了对Python包的查找、下载、安装、卸载的功能.

[root@localhost ~]# curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py [root@localhost ~]# python get-pip.py [root@localhost ~]# echo "alias pip=\"/usr/local/python3/bin/pip\"" >> /etc/profile [root@localhost ~]# pip --version pip 19.3.1 from /usr/local/python3/lib/python3.8/site-packages/pip (python 3.8)

将Python打包为EXE: 我们安装pyinstaller工具,看能不能打包出独立的可执行文件.

[root@localhost ~]# pip install pyinstaller [root@localhost ~]# pip show pyinstaller [root@localhost ~]# pyinstaller -F ./lyshark.py [root@localhost ~]# pyinstaller -F -w -i lyshark.ico lyshark.py  # -w :不提示控制台 

将Python编译为EXE: 通过使用Cython可以将Python编译为exe可执行程序,注意是编译并不是打包.

C:/> python -m cython -3 --embed -o lyshark.c lyshark.py
C:/> cl /c /nologo /Ox /MD /W3 /GS- /DNDEBUG -I"D:\python\include" /Tc lyshark.c /DWIN32
C:/> link lyshark.obj /SUBSYSTEM:CONSOLE /MACHINE:X64 /LIBPATH:"D:\python\libs" C:/> link lyshark.obj /SUBSYSTEM:WINDOWS /MACHINE:X64 /LIBPATH:"D:\python\libs" /ENTRY:"wmainCRTStartup" 

将Python编译为ELF: ELF是Linux系统下的文件运行格式,我们可以Python编译为ELF文件.

[root@localhost ~]# yum install -y epel-release [root@localhost ~]# yum install -y python-pip [root@localhost ~]# yum install -y python-dev* [root@localhost ~]# pip install cython [root@localhost ~]# cython lyshark.py --embed [root@localhost ~]# gcc `python-config --cflags` `python-config --ldflags` lyshark.c -o lyshark 

◆Python 输入输出◆

输入与输出是任何一门编程语言中都存在的东西,计算机的本质也就是输入输出,在学习Python之前,必须要先学会输入输出,Python的输入输出非常简单,输入的话直接使用input函数,输出的话就是print函数.

标准输入的用法: 默认接收都视为字符串,如果需要数字则需要另外强制转换为int()转换为数字.

>>> name = input("请输入你的名字:")
请输入你的名字:lyshark >>> print("Hello " + name)
Hello lyshark >>> age = input("请输入你的年龄:")
请输入你的年龄:22 >>> type(age)
<class 'str'>
>>> age1 = input("请输入你的年龄:")
>>> age1 = int(age1)  #此处强制类型转换
>>> type(age1)
<class 'int'> 

密码输入专用方法: 输入密码时,需要利用getpass模块中的getpass方法,即:

import getpass # 将用户输入的内容赋值给 pwd 变量 pwd = getpass.getpass("请输入密码：")
请输入密码： # 打印输入的内容 print(pwd)

简单格式化输出: 通过使用print函数,我们可以实现简单的格式化输出.

>>> string = "hello lyshark" >>> print(string)
hello lyshark >>> print(string,) # 不让其自动换行 >>> print('hello', end = " ")
>>> >>> string = "the length of (%s) is %d" %("hello lyshark",len("hello lyshark")) >>> print(string)
the length of (hello lyshark) is 13 >>> >>> string = "hello {} --> age {}".format("lyshark",22) >>> print(string)
hello lyshark --> age 22 >>> >>> string = "i am %(age).2f" %{"age":22} >>> print(string)
i am 22.00 

格式化转换输出: 格式化输出十进制,十六进制,八进制.

>>> import math >>> nHex=0x20 >>> print("十六进制=%x,十进制=%d,八进制=%o"%(nHex,nHex,nHex))
十六进制=20,十进制=32,八进制=40 >>> >>> print("PI=%F"%math.pi)
PI=3.141593 >>> print("PI=%10.2f"%math.pi)
PI= 3.14 >>> print("PI=%-10.2f"%math.pi)
PI=3.14 

格式化format的详细用法:

>>> print("i am {0}, age {1}, really {0}".format("lyshark",22))
i am lyshark, age 22, really lyshark
>>> >>> print("i am {name}, age {age}".format(**{"name":"lyshark","age":"22"}))
i am lyshark, age 22 >>> >>> temp = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33]) >>> print(temp)
i am 1, age 2, really 3 >>> >>> temp = "i am {:s}, age {:d}, money {:f}".format("lyshark", 18, 8.1) >>> print(temp)
i am lyshark, age 18, money 8.100000 >>> >>> temp = "%r %r %r %r" >>> print(temp%(1,2,3,4)) 1 2 3 4 >>> >>> print("网站名称:{name},地址:{url}".format(name="myblog",url="www.baidu.com"))
网站名称:myblog,地址:www.baidu.com
>>> >>> site={"name":"myblog","url":"www.baidu.com"} >>> print("网站名称:{name} 地址:{url}".format(**site))
网站名称:myblog 地址:www.baidu.com
>>> >>> my_list = ['myblog','www.baidu.com'] >>> print("网站名称:{0[0]},地址:{0[1]}".format(my_list))
网站名称:myblog,地址:www.baidu.com

◆Python 简单运算◆

运算符用于执行程序代码运算,会针对一个以上操作数项目来进行运算,在Python中运算符大致可以分为7种类型:算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算等,下面的例子将依次介绍这几种运算符的使用技巧.

算数运算符: 用来处理四则运算的符号,所有编程语言都会使用到算术运算符号.

>>> num1 = 10 >>> num2 = 20 >>> >>> num1 + num2 30 >>> num1 - num2 -10 >>> num2 % num1 # 取模:返回除法的余数 0 >>> num2 // num1 # 取整:返回商的整数部分  2 >>> num1 ** num2 # 幂符:返回num1的num2次幂 100000000000000000000 

比较运算符: 比较运算符结果是一个逻辑值,不是TRUE(成立)就是FALSE(不成立)的运算符号.

>>> num1 = 10 >>> num2 = 20 >>> >>> num1 == num2 False >>> num1 != num2 True >>> num1 >= num2 False >>> num1 <= num2 True 

赋值运算符: 基本的赋值运算符是=(不是等号,等号为==),所以对该运算符往往最后读取.

>>> num1 = 10 >>> num2 = 20 >>> >>> num1 = 10 >>> num1 += 10 20 >>> num1 -= 10 10 

位运算符号: 程序中,位运算就是直接对整数在内存中的二进制位进行操作.

>>> a=60 # 60 = 0011 1100  >>> b=13 # 13 = 0000 1101 >>> c=0 >>> >>> c= a & b # 12 = 0000 1100 >>> print("a与b: ",c)
a与b: 12 >>> >>> c= a | b # 61 = 0011 1101  >>> print("a或b: ",c)
a或b: 61 >>> >>> c=a^b # 49 = 0011 0001 >>> print("a异或b:",c)
a异或b: 49 >>> >>> c=a << 2 # 240 = 1111 0000 >>> print("a左移2",c)
a左移2 240 

其他运算符: 其他运算符包括常用的,逻辑运算,成员运算,身份运算等.

>>> num1 = 10 >>> num2 = 20 >>> num3 = 0 >>> list = [10,20,30,40,50]
>>> >>> num1 and num3 0 >>> >>> num1 in list # 判断num1是否在list里面 True >>> num1 not in list False >>> >>> num1 is num3 # 判断两个标识符是不是引用自一个对象 True >>> num1 is num2 False >>> num1 is not num2 True 

四舍五入: 一些特殊需求情况下使用四舍五入等.

>>> import math
>>> >>> math.ceil(3.14) 4 >>> round(3.14) 3 

Python 数据类型

数据类型在数据结构中的定义是一个值的集合以及定义在这个值集上的一组操作,在Python当中数据类型包括数值类型、字符类型组、列表、字典、元组、等类型,下面的例子将依次介绍这几种运算符的使用技巧.

◆数值的类型◆

Python支持int、float、bool、complex(复数),在Python中只有一种整数类型int表示为长整型,像大多数语言一样,数值类型的赋值和计算都是很直观的,数值间的数据互换可以参考如下列表:

int(x) #将x转换为一个整数  long(x) #将x转换为一个长整数  float(x) #将x转换到一个浮点数  complex() #创建一个复数  str(x) #将对象x转换为字符串  repr(x) #将对象x转换为表达式字符串  eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象  tuple(x) #将序列s转换为一个元组  list(x) #将序列s转换为一个列表  chr(x) #将一个整数转换为一个字符  unichr(x) #将一个整数转换为Unicode字符  ord(x) #将一个字符转换为它的整数值  hex(x) #将一个整数转换为一个十六进制字符串  oct(x) #将一个整数转换为一个八进制字符串  

整数转其他数值: 使用转换命令将一个整数转换为其他数值.

>>> temp=100 >>> >>> float(temp) 100.0 >>> complex(temp)
(100+0j) >>> str(temp) '100' 

整数转换字符: 使用转换命令将一个整数转换为字符.

>>> temp=100 >>> >>> chr(temp) 'd' >>> ord(chr(temp)) 100 

进制转换: 使用转换命令实现进制转换.

>>> temp=100 >>> >>> hex(temp) '0x64' >>> oct(temp) '0o144' 

◆字符串类型◆

所谓字符串就是字符的集合,Python支持字符串这种数据类型,且提供了一些丰富的字符串处理函数,以下列表中就是Python所支持的字符串操作函数,接下来我们将找出几个比较常用的字符串函数来进行演示.

str.capitalize() #将字符串的首字母变大写 str.title() #将字符串中的每个单词的首字母大写 str.upper() #将字符串变成大写 str.lower() #将字符串变成小写 str.index() #找出索引对应的字符串 str.find() #找出索引对应的字符串 str.count() #找出字符串中元素出现的次数 str.format() #也是格式化的一种 str.center() #以什么字符从字符串两边填充 str.join() #以str为分隔符连接字符串 str.split() #以什么为分隔符分隔字符串 str.strip() #将字符串两边中的空格去掉 str.replace() #查找替换 str.isupper() #判断是否为大写 str.islower() #判断是否为小写 str.isalnum() #判断是否是字母数字 str.isalpha() #判断是否是字母下划线 str.isdigit() #判断是否是数字 str.isspace() #判断是否为空 str.startswith() #找出以什么为开头的字符元素 str.endswith() #找出以什么为结尾的字符元素 

首字母大写: 使用capitalize()函数,将一个指定字符串首字母变成大写.

>>> str="hello lyshark" >>> >>> str.capitalize() 'Hello lyshark' 

全部首字母大写: 使用title()函数,将字符串中的每一个单词的首字母大写.

>>> str="hello lyshark" >>> >>> str.title() 'Hello Lyshark' 

查找字符串: 使用index()函数,找出指定字符串的索引编号,不存在则报错.

>>> str="hello lyshark" >>> >>> str.index("hello") 0 >>> str.index("lyshark") 6 >>> str.index("mk")
ValueError: substring not found

查找字符串: 使用find()函数,找出指定字符串的索引编号,不存在则返回-1.

>>> str="hello lyshark" >>> >>> str.find("hello") 0 >>> str.find("lyshark") 6 >>> str.find("mk") -1 

统计字符串出现次数: 使用count()函数,统计指定字符串的出现次数.

>>> str="hello lyshark" >>> >>> str.count("h") 2 >>> str.count("l") 3 >>> str.count("hello") 1 >>> str.count("mk") 0 

字符串填充: 使用center()函数,填充指定字符串两边的内容.

>>> str="hello lyshark" >>> >>> str.center(20,'*') '***hello lyshark****' >>> >>> print(str.center(50,'-'))
------------------hello lyshark-------------------

字符串连接: 使用join()函数,将序列中以指定的字符连接生成一个新字符串

>>> str="-" >>> seq=("hello","lyshark","welcome")
>>> >>> print(str.join(seq))
hello-lyshark-welcome >>> list =['1','2','3','4','5'] >>> print(''.join(list)) 12345 >>> 'kill %s' % ' '.join(['1024','2234'])

切割字符串: 使用split()函数,指定分割一个字符串,并保存成列表.

>>> str="hello-lyshark-welcome" >>> >>> str.split("-")
['hello', 'lyshark', 'welcome']

去除字符串两边空格: 使用strip()函数,去除指定字符串两边空格.

>>> str="    hello      lyshark       " >>> str '    hello      lyshark       ' >>> >>> str.strip() 'hello      lyshark' 

去除字符串(左/右)两边空格: 使用str.lstrip()函数去除字符串左边空格rstrip函数则相反.

>>> str="    hello      lyshark       " >>> >>> str.rstrip() '    hello      lyshark' >>> >>> str.lstrip() 'hello      lyshark       ' >>>

字符串查找替换: 使用replace()函数,查找并替换指定字符串.

>>> str="hello lyshark" >>> str 'hello lyshark' >>> >>> str.replace("lyshark","mkdirs") 'hello mkdirs' 

判断是否为大写: 使用isupper()函数,判断指定字符串是否为大写.

>>> str="LYSHARK" >>> str1="lyshark" >>> >>> str.isupper() True >>> str1.isupper() False 

查找开头结尾: 使用startswith()函数,找出指定字母开头的字符元素.

>>> str="hello lyshark welcome" >>> >>> str.startswith("hello") True >>> str.startswith("lyshark") False >>> >>> str.startswith("lyshark") or str.endswith("welcome") True >>> str.startswith("lyshark") and str.endswith("welcome") False 

◆列表的类型◆

列表是Python中最基本的数据结构,同时也是最常用的,列表中的每个元素都分配一个数字-它的位置或索引,第一个索引是0,第二个索引是1,依此类推,,接下来我们将找出几个比较常用的列表操作函数来进行演示.

list.insert() #在列表中指定索引位置前插入元素 list.append() #在列表尾部插入 list.remove() #删除指定的元素 list.pop() #没有指定索引,则弹出最后一个元素,返回的结果是弹出的索引对应的元素 list.copy() #浅复制,只复制第一层,如果有嵌套序列则不会复制,需要复制要导入copy模块 list.extend() #把另外一个列表合并,并不是追加 list.index()    #列表中元素出现的索引位置 list.count() #统计列表中元素的次数 list.reverse() #进行逆序 list.sort() #进行排序,无法把数字和字符串一起排序 list1 + list2 #合并两个列表,返回一个新的列表,不会修改原列表 list * N #把list重复N次,返回一个新列表 

向列表追加数据: 使用append()函数,追加写入几个数据到指定的列表里.

>>> list = [1,2,3] >>> list [1, 2, 3]
>>> >>> list.append(4) >>> list.append(5) >>> list.append(6)
>>> >>> list [1, 2, 3, 4, 5, 6]

向列表插入数据: 使用insert()函数,向指定的列表插入几个数据到指定的位置.

>>> list = ["admin","lyshark"] >>> list ['admin', 'lyshark']
>>> >>> list.insert(1,"python") >>> list ['admin', 'python', 'lyshark']
>>> >>> list.insert(2,"ruby") >>> list.insert(2,"ruby") >>> list ['admin', 'python', 'ruby', 'ruby', 'lyshark']

修改指定数据: 使用names[]变量赋值的方式,修改指定元素的字段值.

>>> list ['admin', 'python', 'ruby', 'ruby', 'lyshark'] >>> list[0]="mkdirs" >>> list ['mkdirs', 'python', 'ruby', 'ruby', 'lyshark']
>>> >>> list[3]="pip" >>> list ['mkdirs', 'python', 'ruby', 'pip', 'lyshark']

删除指定数据: 使用remove()函数,删除指定数据,或使用del()函数来删除.

>>> list ['mkdirs', 'python', 'ruby', 'pip', 'lyshark'] >>>  >>> del list[2] #通过下标删除元素 >>> list ['mkdirs', 'python', 'pip', 'lyshark'] >>>  >>> list.remove("python") #删除指定的元素 >>> list ['mkdirs', 'pip', 'lyshark'] >>>  >>> list.pop() #删除列表的最后一个元素 'lyshark' >>> list.pop() 'pip' >>> list ['mkdirs']

扩展一个列表: 使用extend()函数,将一个列表追加到另一个列表的后面.

>>> list1 = ["admin","guest","lyshark"] >>> list2 = [1,2,3]
>>> >>> list1.extend(list2) >>> list1
['admin', 'guest', 'lyshark', 1, 2, 3]

浅COPY列表: 使用copy()函数,实现列表的浅Copy.

>>> list1
['admin', 'guest', 'lyshark', 1, 2, 3]
>>> >>> list1_copy = list1.copy() >>> list1_copy
['admin', 'guest', 'lyshark', 1, 2, 3]

统计元素次数: 使用count()函数,统计列表中元素出现的次数.

>>> list = ["admin","admin","lyshark","mkdirs"]
>>> >>> list.count("admin") 2 >>> list.count("mkdirs") 1 

正反向排序: 使用sort(),reverse()函数,给指定列表元素排序.

>>> list = ["admin","python","ruby","1","3","6","9"] >>> list ['admin', 'python', 'ruby', '1', '3', '6', '9']
>>> >>> list.sort() #正向排序,必须元素类型一致 >>> list ['1', '3', '6', '9', 'admin', 'python', 'ruby']
>>> >>> list ['1', '3', '6', '9', 'admin', 'python', 'ruby'] >>> list.reverse() #反向排序,必须元素类型一致 >>> list ['ruby', 'python', 'admin', '9', '6', '3', '1']

获取元素下标: 使用index()函数,来获取元素的下标.

>>> list ['ruby', 'python', 'admin', '9', '6', '3', '1']
>>> >>> list.index("admin") 2 >>> list.index("1") 6 

列表的切片: 使用[]实现列表的各种切片操作.

>>> list=[1,2,3,4,5,6,7,8,9,0]
>>> >>> list[1:4] #取出下标1-4的元素,不包括4 [2, 3, 4]
>>> >>> list[1:-1] #取出下标1至-1,不包括-1 [2, 3, 4, 5, 6, 7, 8, 9]
>>> >>> list[1:] #取出下标从1到最后的数据 [2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> >>> list[:] #取出所有元素 [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> >>> list[0::2] #取元素时每次格2格 [1, 3, 5, 7, 9]

通过分片删除数据: 通过使用分片来清除指定列表中的数据.

>>> list [123, 111, 111, 111, 8, 7, 6, 5, 4, 3, 2, 1] >>> list[0:3]
[123, 111, 111]
>>> >>> list[0:3]=[] #将下标0-3替换成空,不包括3 >>> print(list)
[111, 8, 7, 6, 5, 4, 3, 2, 1]
>>>

嵌套列表的实现: 一次性声明两个列表,并于数据名称相关联.

>>> list1,list2 = [[1,"a","b"],[2,"a","b"]]
>>> >>> print(list1)
[1, 'a', 'b'] >>> print(list2)
[2, 'a', 'b']

查找元素并修改(1): 查找列表中的指定元素,并修改,只修改第一次发现的.

[root@localhost]# cat test.py #!/usr/bin/python name = [1,2,3,4,5,1,5,6] if 1 in name:
    num_of_ele = name.count(1)
    position_of_ele = name.index(1)
    name[position_of_ele] = 888 print(name)

[root@localhost]# python test.py  [888, 2, 3, 4, 5, 1, 5, 6]

查找元素并修改(2): 查找列表中的指定元素,并批量修改,修改所有的.

[root@localhost]# cat test.py #!/usr/bin/python name = [1,2,3,4,5,1,5,6] for i in range(name.count(1)):
    ele_index = name.index(1)
    name[ele_index] = 8888888 print(name)

[root@localhost]# python test.py [8888888, 2, 3, 4, 5, 8888888, 5, 6]

◆字典的类型◆

字典是另一种可变容器模型,且可存储任意类型对象,字典是使用键值对的数据类型,字典的每个键值(key=>value)用冒号作为分割符,而键值对与键值对之间则用逗号分割,整个字典都被包括在花括号中,且字典还有两个特性,第一个特性字典中的数据是无序存储的,第二个特性字典中的key必须是唯一的,所以Key天生去重,如下是字典的几种格式声明:

person = {"name": "lyshark", "age": 22}
person = dict({"name": "lyshark", "age": 22})

info = { 'stu1': "加藤鹰", 'stu2': "波多野结衣", 'stu3': "小泽玛利亚",
}

字典需要使用字典专有的操作函数,字典的常用函数有以下这几种,后面我会使用不同的例子进行说明.

dict.get(key) #取得某个key的value dict.has_key(key) #判断字典是否有这个key,在python3中已经废除,使用in判断 dict.keys() #返回所有的key为一个列表 dict.values() #返回所有的value为一个列表 dict.items() #将字典的键值拆成元组,全部元组组成一个列表 dict.pop(key) #弹出某个key-value dict.popitem() #随机弹出key-value dict.clear() #清除字典中所有元素 dict.copy() #字典复制,d2=d1.copy()是浅复制,如果深复制需要copy模块 dict.fromkeys(s) #生成一个新字典 dict.update(key) #将一个字典合并到当前字典中 dict.iteritems() #生成key-value迭代器,可以用next()取下个key-value dict.iterkeys() #生成key迭代器 dict.itervalues() #生成values迭代器 

增加字典: 在info字典的基础上,增加一个字段info["stu4"] = "苍老师".

>>> info
{'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚'} >>> info["stu4"] = "苍老师" >>> >>> info
{'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚', 'stu4': '苍老师'}

修改字典: 在info字典的基础上,修改将stu1:加藤鹰修改为stu1:金手指.

>>> info
{'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚', 'stu4': '苍老师'}
>>> >>> info["stu1"] = "金手指" >>> info
{'stu1': '金手指', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚', 'stu4': '苍老师'}

删除字典: 在info字典的基础上,删除几个字典,以下提供多种删除方法.

>>> info
{'stu1': '金手指', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚', 'stu4': '苍老师'}
>>> >>> info.pop("stu1") #通过pop函数删除 '金手指' >>> info
{'stu2': '波多野结衣', 'stu3': '小泽玛利亚', 'stu4': '苍老师'}
>>> >>> del info["stu4"] #通过del命令删除 >>> info
{'stu2': '波多野结衣', 'stu3': '小泽玛利亚'}
>>> >>> info.popitem() #随机删除元素 ('stu3', '小泽玛利亚')

查找字典: 在info字典基础上,完成几个查询任务,这里提供几种方法.

>>> info
{'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚'}
>>> >>> "stu1" in info #标准的查询方式 True >>> >>> info.get("stu1") #使用get函数查询 '加藤鹰' >>> >>> info["stu2"] '波多野结衣' 

更新字典: 在info字典的基础上,更新字典内容,将temp字典与info字典合并.

>>> info
{'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚'}
>>> >>> temp = {1:2,"stu4":"苍老师"}
>>> >>> info.update(temp) >>> info
{'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚', 1: 2, 'stu4': '苍老师'}

遍历字典: 这里提供两种字典遍历方法,建议使用第二种,因为其遍历速度最快.

>>> info = {'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚'}
>>> >>> for keys,values in info.items(): ...  print(keys,values)
...
stu1 加藤鹰
stu2 波多野结衣
stu3 小泽玛利亚 >>> for keys in info: ...  print(keys,info[keys])
...
stu1 加藤鹰
stu2 波多野结衣
stu3 小泽玛利亚

索引字典: 字典也支持索引的方式获取字典中的元素,只不过必须以key作为索引.

>>> info = {'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚'}
>>> >>> info['stu2'] '波多野结衣' >>> >>> len(info) 3 >>> >>> dict = {"姓名":"加藤鹰","得分":[98,99,87]}
>>> >>> dict["姓名"] '加藤鹰' >>> dict["得分"]
[98, 99, 87] >>> dict["得分"][2:]
[87]

字典解包: 将字典分解为独立的元组并将元组赋值给其他变量.

>>> dict = {"姓名":"加藤鹰","得分":[98,99,87]} >>> t1,t2 = dict.items()
>>> >>> print(t1)
('姓名', '加藤鹰') >>> print(t2)
('得分', [98, 99, 87])
>>> >>> k1,k2 = {"x":100,"y":200} >>> print(k1)
x

列表合并为字典: 将两个列表合成一个字典,其中list1是key,list2是values.

>>> dict = {} >>> list = [100,200,300,400,500] >>> head = ["MemTotal","MemFree","Cached","SwapTotal","SwapFree"]
>>> >>> for (keys,values) in zip(head,list): ...  dict[keys] = values
... >>> dict {'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>> >>> dict(map(lambda x,y:[x,y],head,list))
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>> >>> dict(zip(head,list))
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}

字典键值对调: 将字典中的键与字典中的值进行位置的对调.

>>> {key:value for key,value in zip(head,list)}
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500} >>> {value:key for key,value in zip(head,list)}
{100: 'MemTotal', 200: 'MemFree', 300: 'Cached', 400: 'SwapTotal', 500: 'SwapFree'}

字典拆分为列表: 将一个完整的字典拆分为两个列表.

>>> dict = {'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚'} >>> keys= dict.keys() >>> values = dict.values()
>>> >>> print("keys:{}".format(keys))
keys:dict_keys(['stu1', 'stu2', 'stu3'])
>>> >>> dict = {'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚'}
>>> >>> keys,values = zip(*dict.items()) >>> print("Keys:",str(keys))
Keys: ('stu1', 'stu2', 'stu3') >>> dict = {'stu1': '加藤鹰', 'stu2': '波多野结衣', 'stu3': '小泽玛利亚'}
>>> >>> keys = [] >>> values = [] >>> items = dict.items() >>> for x in items: ...  keys.append(x[0]),values.append(x[1])
... >>> print(str(keys))
['stu1', 'stu2', 'stu3']

字典合并与拷贝: 合并字典,但是在有相同的key时会覆盖原有的key的值.

>>> dict1 = {"x":1,"y":2} >>> dict2 = {"a":3,"b":4} >>> dict3 = {}
>>> >>> dict3 = {**dict1,**dict2} >>> print(dict3)
{'x': 1, 'y': 2, 'a': 3, 'b': 4}
>>> >>> dict3.update(dict1) >>> dict3.update(dict2) >>> print(dict3)
{'x': 1, 'y': 2, 'a': 3, 'b': 4}
>>> >>> import copy >>> n1 = {"k1": "wu", "k2": 123, "k3": ["lyshark", 456]} >>> n2 = {}
>>> >>> n2 = copy.deepcopy(n1) >>> print(n2)
{'k1': 'wu', 'k2': 123, 'k3': ['lyshark', 456]}

复杂表格数据存储:

>>> dict1 = {"name":"admin","age":19,"salary":3000,"address":"beijing"} >>> dict2 = {"name":"guest","age":20,"salary":4000,"address":"shanghai"} >>> dict3 = {"name":"lyshark","age":21,"salary":5000,"address":"shenzhen"} >>> table = [dict1,dict2,dict3] # 用于获取指定人的指定字段数据 >>> print(table[1].get("name"))
guest >>> print(table[2].get("address"))
shenzhen # 打印表格中所有人的名字 >>> for i in range(len(table)): ...  print(table[i].get("name"))
...
admin
guest
lyshark

◆元组的类型◆

元组是Python中常用的一种数据结构,元组由不同的元素组成,每个元素可以存储不同类型的数据,如字符串、数字甚至元组,元组是"写保护"的,即元组创建后不能再做任何修改操作,元组通常代表一行数据,而元组中的元素代表不同的数据项,元组一旦创建,便不能再修改,所以又叫只读列表,元组使用小括号,列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可.

创建元组: 同个几个实例看一下元组是如何被创建的.

>>> tup1 = ("google","baidu",1997,1998) >>> tup2 = (1,2,3,4,5,6,7) >>> tup3 = "a","b","c","d" >>> >>> tup1
('google', 'baidu', 1997, 1998) >>> tup2
(1, 2, 3, 4, 5, 6, 7) >>> tup3
('a', 'b', 'c', 'd')
>>> >>> type(tup1)
<class 'tuple'> 

访问元组: 元组可以使用下标索引来访问元组中的值.

>>> tup1
('google', 'baidu', 1997, 1998)
>>> >>> print("tup1[0:]",tup1[0])
tup1[0:] google >>> print("tup1[1:2]",tup1[1:2])
tup1[1:2] ('baidu',)

连接元组: 元组中的元素值是不允许修改的,但我们可以对元组进行连接组合.

>>> tup1 = (1,2,3,4) >>> tup2 = ("abc","xyz")
>>> >>> tup3 = tup1+tup2 >>> print(tup3)
(1, 2, 3, 4, 'abc', 'xyz')

删除元组: 元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组.

>>> tup = ("admin","lyshark", 1997, 2000)
>>> >>> print(tup)
('admin', 'lyshark', 1997, 2000) >>> del tup; >>> print(tup)

列表转元组: 将一个列表,强制转换成元祖.

>>> list = ["admin","lyshark","guest"]
>>> >>> tuple = tuple(list)
>>> >>> tuple ('admin', 'lyshark', 'guest')

数据统计: 通过使用count(),index()函数统计元组中的其他数据.

>>> tuple ('admin', 'lyshark', 'guest')
>>> >>> tuple.count("lyshark") #统计lyshark出现次数 1 >>> tuple.index("lyshark") #统计lyshark索引位置 1 

元素修改(拓展): 在没有嵌套的情况,元组是不可变对象,但是元组内的列表是可变的.

>>> tup=("lyshark",[1,2,3,4,5]) >>> tup
('lyshark', [1, 2, 3, 4, 5])
>>> >>> tup[1].pop() 5 >>> tup
('lyshark', [1, 2, 3, 4])

元组解包(拓展): 将两个元组,查分开,分别存储在两个变量中.

>>> tup1,tup2=((1,2,3),("a","b","c")) >>> print(tup1)
(1, 2, 3)
>>> >>> print(tup2)
('a', 'b', 'c')

◆集合的类型◆

集合是一个无序的,不重复的数据组合,集合天生去重,把一个列表变成集合,就自动去重了,集合不支持：索引、元素获取、切片,且没有特定语法格式,只能通过工厂函数创建set,像字符串则直接创建即可,set集合中的元素必须是可迭代对象,所有元素不会重复,不像list列表是可以重复.

set.add(item) #将item添加到set中,如果item已经在set中,则无任何效果 set.remove(item) #从set中删除item,如果item不是set的成员,则引发KeyError异常 set.discard(item) #从set中删除item.如果item不是set的成员,则无任何效果 set.pop() #随机删除一个集合元素,并从set删除,有变量接收则会接收删除到的元素 set.clear() #删除set中的所有元素 set.copy() #浅复制 set.update(t) #将t中的所有元素添加到set中,t可以是另一个集合、一个序列 set.union(t) #求并集,返回所有在set和t中的元素 set.intersection(t) #求交集,返回所有同时在set和t中的都有的元素 set.intersection_update(t) #计算set与t的交集,并将结果放入set set.difference(t) #求差集,返回所有在set中,但不在t中的元素 set.difference_update(t) #从set中删除同时也在t中的所有元素 set.symmetric_difference(t) #求对称差集,返回所有set中没有t中的元素和t中没有set中的元素组成的集合 set.sysmmetric_difference_update(t) #计算set与t的对称差集,并将结果放入set set.isdisjoint(t) #如果set和t没有相同项,则返回True set.issubset(t) #如果s是t的一个子集,则返回True set.issuperset(t) #如果s是t的一个超集,则返回True 

创建集合: 使用两种方式分别创建一个集合元素.

>>> s = {"tom","cat","name","lyshark"} >>> s = set({"tom","cat","name","lyshark"})
>>> >>> s
{'tom', 'cat', 'name', 'lyshark'} >>> type(s)
<class 'set'> 

定义可变集合: 定义一个可变集合,集合中的元素不可重复,都是不同的.

>>> set_test = set("hello") >>> set_test
{'o', 'e', 'l', 'h'}

定义不可变集合: 定义一个不可变集合,集合中的元素不可重复,都是不同的.

>>> set_test = set("hello") >>> set_test
{'o', 'e', 'l', 'h'}
>>> >>> no_set_test = frozenset(set_test) >>> no_set_test frozenset({'o', 'e', 'l', 'h'})

求子集: 子集为某个集合中一部分的集合,故亦称部分集合.

>>> A = set('abcd') >>> B = set("cdef") >>> C = set("ab")
>>> >>> C#C是A的子集 True >>> C.issubset(A) #C是A的子集 True >>> C#C不是B的子集 False 

>>> A
{'d', 'a', 'c', 'b'} >>> B
{'f', 'd', 'e', 'c'}
>>> >>> A | B
{'f', 'b', 'c', 'a', 'e', 'd'} >>> A.union(B)
{'f', 'b', 'c', 'a', 'e', 'd'}

>>> A
{'d', 'a', 'c', 'b'} >>> B
{'f', 'd', 'e', 'c'}
>>> >>> A & B
{'c', 'd'} >>> A.intersection(B)
{'c', 'd'}

>>> A
{'d', 'a', 'c', 'b'} >>> B
{'f', 'd', 'e', 'c'}
>>> >>> A - B
{'a', 'b'} >>> A.difference(B)
{'a', 'b'}

>>> A
{'d', 'a', 'c', 'b'} >>> B
{'f', 'd', 'e', 'c'}
>>> >>> A ^ B
{'f', 'b', 'a', 'e'} >>> A.symmetric_difference(B)
{'f', 'b', 'a', 'e'}

>>> s = {1,2,3,4,5,6} >>> s
{1, 2, 3, 4, 5, 6} >>> s.add("s") >>> s.add("e") >>> s.add("t")
>>> >>> s
{1, 2, 3, 4, 5, 6, 't', 's', 'e'}

>>> s
{1, 2, 3, 4, 5, 6, 't', 's', 'e'}
>>> >>> s.clear()
>>> >>> s set()

>>> s = {1,2,3,4,5} >>> s
{1, 2, 3, 4, 5}
>>> >>> s.remove(3) >>> s
{1, 2, 4, 5}

>>> s ={"p","y"} >>> s
{'p', 'y'}
>>> >>> s.update(["H","e"],{"1","2","3"}) >>> s
{'H', '1', 'y', 'p', '2', 'e', '3'}

# 数据库中原有 old_dict = { "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }
} # cmdb 新汇报的数据 new_dict = { "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 }, "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }
}
old_set=set(old_dict)
new_set=set(new_dict)
 
del_set=old_set.difference(new_set)
add_set=new_set.difference(old_set)
flush_set=old_set.intersection(new_set) for i in del_set:
    old_dict.pop(i) for i in add_set:
    old_dict[i]=new_dict[i] for i in flush_set:
    old_dict[i] = new_dict[i]
print(old_dict)

# 数据库中原有 old_dict = { "#1":8, "#2":4, "#3":2,
} # cmdb 新汇报的数据 new_dict = { "#1":4, "#3":4, "#4":2,
}


old_set = set(old_dict.keys())
print(old_set)
new_set = set(new_dict.keys())
print(new_set)

remove_set = old_set.difference(new_set)
print(remove_set)

add_set = new_set.difference(old_set)
print(add_set)

update_set = old_set.intersection(new_set)
print(update_set)

s + r #连接字符串,与数据 s * n #重复s的n次复制 v1,v2...vn = s #变量解包(unpack) s[i] #索引 s[i:j] #切片 s[i:j:stride] #扩展切片 x in s,x not in s #成员关系 for x in s: #迭代 all(s) #如果s中的所有项都为True,则返回True any(s) #如果s中的任意项为True,则返回True len(s) #长度,元素个数 min(s) #s中的最小项 max(s) #s中的最大项 sum(s [,initial]) #具有可选初始值的项的和 

>>> temp = [1,1,1,1,1,1] >>> temp1 = [1,1,1,1,0,1]
>>> >>> all(temp) True >>> all(temp1) False 

>>> temp = [1,1,1,1,1,1] >>> temp1 = [1,1,1,1,0,1]
>>> >>> any(temp) True >>> any(temp1) True 

>>> temp = [1,1,1,1,1,1] >>> len(temp) 6 

>>> temp = [1,2,3,4,5,6,7,8,9]
>>> >>> min(temp) 1 

>>> temp = [1,2,3,4,5,6,7,8,9]
>>> >>> max(temp) 9 

>>> f=open("./test.txt","r")
>>>

>>> temp=os.popen("ifconfig").readlines() >>> temp
['eth0: flags=4163  mtu 1500\n']

>>> f=open("./test.txt","r") >>> f.read()

>>> f=open("./test.txt","r") >>> f.readline() 'root:x:0:0:root:/root:/bin/bash\n' >>> f.readline() 'bin:x:1:1:bin:/bin:/sbin/nologin\n' >>> f.readline() 'daemon:x:2:2:daemon:/sbin:/sbin/nologin\n' 

>>> f=open("./test.txt","r") >>> f.readlines()

>>> f=open("./test.txt","r") >>> f.tell() #查询当前光标所在位置 0 >>> f.readline() #读取一行后 'root:x:0:0:root:/root:/bin/bash\n' >>>  >>> f.tell() #再次查询光标所在位置 32 >>>  >>> f.read() #完全读取后，光标此时在文件最后面.. 'bin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\n' >>> >>> f.seek(32) #移动光标到32 >>>  >>> f.read() #重新读取数据 'bin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\n' 

>>> import sys >>> import time >>>  >>> for i in range(40): ...  sys.stdout.write("#") ...  sys.stdout.flush() #强制将内存中的数据写入硬盘 ...  time.sleep(0.1)

>>> f=open("./test.txt","r") >>> f.readlines() >>> f.close()

>>> f = open("./test.txt", "r") >>> print ("文件名为: ", f.name) >>> for index in range(5): ...  line = next(f) ...  print ("第 %d 行 - %s" % (index,line)) >>> f.close()

>>> f = open("./test.txt", "r+") >>> print ("文件名为: ", f.name) >>> f.truncate(10) #截取10个字节 >>> str = f.read() >>> print ("读取数据: %s" % (str)) >>> f.close()

>>> with open('test.txt') as f: ...  print(f.read())

import sys import linecache

count = len(open("./ip.log","r").readlines())
print("文件行数(包括空格): %d" %count)

count = linecache.getlines("./ip.log")
print("文件行数(支持大文件): %d" %len(count))

# -*- coding: utf-8 -*- import sys

number = 38 user_input = int(input("输入一个数字:")) if user_input == number:
    print("你猜对了!") elif user_input < number: print("猜小了!") else:
    print("猜大了!")

import sys

count = 1 sum = 0 while count <=100: sum+=count
    count+=1 print(sum)

import os

count = 0 while count <=9:
    print(count, end=' ') if count == 5: break count += 1 else:
    print('end')

import sys

string = "hello lyshark" while string:
    print(string)
    string = string[:-1] else:
    print("gae over")

>>> list=[1,2,3,4,5,6] >>> count =0 >>> >>> while list: ...  print(list[0]) ...  list.pop(0)
... >>> list=[1,2,3,4,5,6] >>> while list: ...  print(list[-1]) ...  list.pop()
... >>> list=[1,2,3,4,5,6] >>> while count < len(list): ...  print(list[count]) ...  count+=1 

>>> num=0 >>> sum=0 >>> while num <=100: ...  if num %2 ==0: ...  sum=sum+num ...  else: ...  pass ...  num=num+1 

>>> d1 = {'x':1,'y':23,'z':78} >>> keylists = d1.keys() >>> while keylists:
        print(keylists[0])
        keylists.pop[0] else:
        print(len(d1))

>>> l1 = [] >>> x = 1 >>> while x < 100:
        l1.append(x)
        x += 2 

>>> l1 = [0,1,2,3,4,5,6] >>> l2 = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'] >>> d1 = {} >>> count = 0 >>> if len(l1) == len(l2): while count < len(l1):
        d1[l1[count]] = l2[count]
        count += 1 >>> print(d1)

count = 0 while True:
    print("hello lyshark:",count)
    count +=1 if count == 100:
        print("break") break 

import getpass import os

name = "lyshark" pwd = "123123" count = 0 while True: if count < 3:
        print("请输入用户名和密码:")
        username = input("用户名:")
        password = getpass.getpass("密码:") if username == name and password == pwd:
            print("恭喜你登陆成功！") break else:
            print("登陆失败！用户名或者密码错误") else:
        print("你已经输错3次,正在退出....") break count += 1 

import os

names = ["tom","admin","lyshark","jack"] for x in names:
    print(x)

import os

names = ["tom","admin","lyshark","jack"] for x in range(len(names)):
    print(names[x])

import os

T = [(1,2),(3,4),(5,6),(7,8)] for (a,b) in T:
    print(a,b)

import os for i in range(10): if i % 2 == 0: continue print(i, end=' ')

import os

names = ['Tom', 'Peter', 'Jerry', 'Jack', 'Lilly'] for i in range(len(names)): if i >= 3: break print(names[i])

import os for j in range(1, 10): for i in range(1, j+1):
        print('%d*%d=%d' % (i, j, i*j), end='\t')
        i += 1 print()
    j += 1 

>>> string="hello world my name lyshark" >>> for i in range(0,len(string),2): ...  print(string[i]) >>> list=[1,2,3,4,5] >>> for i in range(len(list)): ...  list[i]+=1 >>> list [2, 3, 4, 5, 6] >>> for i in range(1,10,2):
    print(i)

>>> list=["苍井空","小泽玛利亚","吉泽明步"] >>> for (x,y) in enumerate(list,1):
    print(x,y) 1 苍井空 2 小泽玛利亚 3 吉泽明步

>>> L1 = [1,2,3,4,5] >>> L2 = ['a','b','c','d','e',] >>> zip(L1,L2) >>>  >>> keys = [1,2,3,4,5,6,7] >>> vaules = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'] >>> D = {} >>> for (k,v) in zip(keys,values)
       D[k] = v >>> D

>>> d1 = {'x':123,'y':321,'z':734} >>> for (k,v) in d1.items():
    print(k,v)
    
y 321 x 123 z 734 

>>> l1=['Sun','Mon','Tue','Wed','Thu','Fri','Sat'] >>>  >>> for i in range(1,len(l1),2):
    print(l1[i])

>>> l1=['Sun','Mon','Tue','Wed','Thu','Fri','Sat'] >>> l2=['Sun','Mon','Tue','Thu','Sat'] >>> l3 = [] >>> for i in l1: >>>  if i not in l2: >>>  l3.append(i)

>>> namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7'] >>> removelist=['stu3','stu7','stu9'] >>> for i in removelist: >>>  if i in namelist: >>>  namelist.remove(i) >>> print(namelist)

>>> for i in range(1,5): ...  for j in range(1,5): ...  for k in range(1,5): ...  if(i!=k) and (i!=j) and(j!=k): ...  print(i,j,k)
...

# -*- coding: UTF-8 -*- year = int(input('year:\n'))
month = int(input('month:\n'))
day = int(input('day:\n'))
 
months = (0,31,59,90,120,151,181,212,243,273,304,334) if 0 < month <= 12: sum = months[month - 1] else: print ('data error') sum += day
leap = 0 if (year % 400 == 0) or ((year % 4 == 0) and (year % 100 != 0)):
    leap = 1 if (leap == 1) and (month > 2): sum += 1 print ('it is the %dth day.' % sum)

import os import sys for x in range(1,10):
        print() for y in range(1,x+1):
                print("%d*%d=%d "%(y,x,x*y),end="")

import os import sys

ls="Type help() for interactive help, or help(object) for help about object" find="help" for x in range(len(ls)):
        temp=len(find) if str(ls[x:x+temp]) == str(find):
                print(ls[x:x+temp],x) break 

import os import time

dic={1:"admin",2:"guest"} for key,value in dict.items(dic):
        print(key,value)
        time.sleep(1)

import os import string

strs=input("请输入一个字符串:")

letters=0 space=0 digit=0 others=0 for x in range(len(strs)):
        ch=strs[x] if ch.isalpha():
                letters+=1 elif ch.isspace():
                space+=1 elif ch.isdigit():
                digit+=1 else:
                others+=1 print("char=%d,space=%d,digit=%d,others=%d"%(letters,space,digit,others))

import os import sys def login(x,y): fp=open("db","r",encoding="utf-8")
    data=fp.readline().split(":")
    count=len(open("db","r").readlines())

    username=data[0]
    password=data[1] for i in range(3): if x==username.strip() and y==password.strip():
            print("登陆成功") break else:
            data=fp.readline().split(":")
            username=data[0]
            password=data[1] continue fp.close()

login("admin","admin")
login("lyshark","lyshark")

list= [11,22,33,44,55,66,77,88,99]
bignum=[]
smallnum=[] dir={} for num in list: if num>66:
        bignum.append(num) if num<66:
        smallnum.append(num) else: pass dir['k1']=bignum dir['k2']=smallnum
print(dir)

li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"} for i in li: if i.strip().capitalize().startswith('A') and i.strip().endswith('c'):
        print(i) for i in tu: if i.strip().capitalize().startswith('A') and i.strip().endswith('c'):
        print(i) for i in dic.values(): if i.strip().capitalize().startswith('A') and i.strip().endswith('c'): print (i)

#方法一 l1=[1,2,3,4]
l2=["手机", "电脑", '鼠标垫', '游艇']
d=dict(zip(l1,l2))
print(d)
num=input("请输入商品编号：")
print("你选择的商品为 %s" %d[int(num)]) #方法二 li = ["手机", "电脑", '鼠标垫', '游艇'] for k, i in enumerate(li):
    print(k,i)
k=input("请输入商品编号：")
print("你选择的商品为 %s" % li[int(k)])

# -*- coding:utf-8 -*- age = 22 count = 0 for i in range(10): if count < 3:
        a = int(input("请输入一个猜测的数:")) if a == age:
            print("恭喜你,答对了") break elif a > age:
            print("你猜的数字大了") else:
            print("你猜的数字小了") else:
        b = input("这都猜不对,你继续玩吗？(yes or not):") if b == 'yes':
            count = 0 continue else:
            print("Bye!下次再玩")

    count += 1 

dic = { "河北": { "石家庄": ["鹿泉", "藁城", "元氏"], "邯郸": ["永年", "涉县", "磁县"],
    }, "湖南": { "长沙":['a','b','c'], "株洲":['d','e','f']
    }, "湖北": { "武汉":['g','h','i'], "黄石":['j','k','l']
    }
} for k in dic.keys():
    print(k)
flag=True while flag:
    n=input("请输入你所在省：") for k in dic.keys(): if n in dic.keys(): if k == n: for i in dic[n].keys():
                    print(i)
                w = input("请输入你所在的城市：") for i in dic[n].keys(): if w in dic[n].keys(): if i == w: for k in dic[n][w]:
                                print(k)
                            s=input("请输入你所在的县：") for j in dic[n][w]: if s in dic[n][w]: if j==s:
                                        print("你所在的位置是：%s省%s市%s县" % (n,w,s))
                                        flag = False break else:
                                    print('不存在，请重新输入') break else:
                        print('不存在，请重新输入') break else:
            print('不存在，请重新输入') break 

product = [
    ("iphone",5800),
    ("watch",380),
    ("bike",800),
    ("book",120),
    ("computer",4000)
]
 
shopping_car = []
 
salary = input("请输入你的金钱: ") if salary.isdigit():
    salary = int(salary) while True: for i in enumerate(product):
            print(i)
 
        user_choice = input(">>>或者q:") if user_choice.isdigit():
            user_choice = int(user_choice) if user_choice >= 0 and user_choice < len(product):
                p_item = product[user_choice] if salary >= p_item[1]:
                    shopping_car.append(p_item[0])
                    salary -= p_item[1]
                    print("你购买了\033[32m%s\033[0m,你的余额剩余\033[31m%s\033[0m" % (p_item[0], salary)) else:
                    print("\033[31m你的余额不足\033[0m") else:
                print("你输入的项目[%s]不存在,请重新输入" % user_choice) elif user_choice == 'q':
            print("你购买了这些商品:".center(30,"-")) for i in shopping_car:
                print("\033[32m%s\033[0m" %i)
            print("\033[31m余额%s\033[0m" %salary)
            exit() else:
            print("你输入的[%s]不存在" % user_choice) else:
    print("你输入的金额不正确！请重新输入金额！")

>>> list = [1,2,3,4,5,6,7,8,9,10]
>>> >>> item = list.__iter__() >>> type(item)
<class 'list_iterator'>
>>>
>>> item.__next__()
1
>>> item.__next__()
2
>>> next(item)
3
>>> next(item)
4 

>>> listvar = ["吕洞宾", "张果老", "蓝采和", "特乖离", "和香菇", "汉钟离", "王文"]
>>> >>> iter = enumerate(listvar) # 转换为迭代器 >>> dict = tuple(iter) # 转换为元组 >>> print(dict)
((0, '吕洞宾'), (1, '张果老'), (2, '蓝采和'), (3, '特乖离'), (4, '和香菇'), (5, '汉钟离'), (6, '王文'))

>>> listvar = ["吕洞宾", "张果老", "蓝采和", "特乖离", "和香菇", "汉钟离", "王文"] >>> item = listvar.__iter__()
>>> >>> while True: ...  try: ...  temp = next(item) ...  print(temp) ...  except StopIteration: ...  break 

>>> temp1 = [1,2,3,4,5] >>> temp2 = [ x ** 2 for x in temp1 ] >>> temp1
[1, 2, 3, 4, 5] >>> temp2
[1, 4, 9, 16, 25]

>>> temp1 = [1,2,3,4,5] >>> temp2 = [ x**2 for x in temp if x>=2 ] >>> temp1
[1, 2, 3, 4, 5] >>> temp2
[4, 9, 16, 25]

>>> temp = [ (x**2)/2 for x in range(1,10)] >>> temp
[0.5, 2.0, 4.5, 8.0, 12.5, 18.0, 24.5, 32.0, 40.5]

>>> temp1=["x","y","z"] >>> temp2=[1,2,3] >>> temp3=[ (i,j) for i in temp1 for j in temp2 ] >>> temp3
[('x', 1), ('x', 2), ('x', 3), ('y', 1), ('y', 2), ('y', 3), ('z', 1), ('z', 2), ('z', 3)]

>>> import os >>> file_list=os.listdir("/var/log") >>> file_log=[ i for i in file_list if i.endswith(".log") ] >>> print(file_log)
['boot.log', 'yum.log', 'ecs_network_optimization.log', 'ntp.log'] >>> file_log=[ i for i in os.listdir("/var/log") if i.endswith(".log") ] >>> print(file_log)
['boot.log', 'yum.log', 'ecs_network_optimization.log', 'ntp.log']

>>> lis = [x*x for x in range(10)] >>> print(lis)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> generator = (x*x for x in range(10)) >>> print(generator)
object at 0x0000022E5C788A98>

>>> generator = (x*x for x in range(10)) >>> print(next(generator)) 0 >>> print(next(generator)) 1 >>> print(next(generator)) 4 >>> print(next(generator)) 9 

>>> generator = (x*x for x in range(10)) >>>  >>> for i in generator:
    print(i,end="") 0149162536496481 

>>> import sys >>>  >>> yie=( i**2 for i in range(1,10) ) >>> next(yie) 1 >>> next(yie) 4 >>> next(yie) 9 >>> for j in ( i**2 for i in range(1,10)):print(j/2)

>>> import sys >>>  >>> def func(): yield 1 yield 2 yield 3 yield 4 yield 5 >>> temp=func() >>> temp.__next__() 1 >>> temp.__next__() 2 >>> temp.__next__() 3 

>>> import sys >>>  >>> def yieldNum(x): y=0 while (y <= x): yield y
        y += 1 >>> yie=yieldNum(5) >>> for i in yie:
    print(i)

>>> def yieldNum(): x=1 while (x <=10 ): yield x ** 2 x += 1 >>> yie=yieldNum() >>>  >>> for i in yie:
    print(i)

>>> def xrange(num): temp=-1 while True:
        temp=temp+1 if (temp >= num): return else: yield temp >>> xrange(10)
object xrange at 0x038E3030>

>>> def fib(max): n,a,b=0,0,1 while n < max: yield b
        a,b=b,a+b
        n+=1 return "done" >>> f=fib(5) >>> f
object fib at 0x038F4A20>

import time def consumer(name): print("%s 准备吃包子啦!" %name) while True:
       baozi = yield print("包子[%s]来了,被[%s]吃了!" %(baozi,name)) def producer(name): c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!") for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)
 
producer("alex")