hex()

 转换一个整数对象为十六进制的字符串

 >>> hex(16)

 '0x10'

 >>> hex(18)

 '0x12'

 >>> hex(32)

 '0x20'

 oct()

 转换一个整数对象为八进制的字符串

 >>> oct(8)

 '0o10'

 >>> oct(166)

 '0o246'

 bin()

 转换一个整数对象为二进制字符串

 >>> bin(10)

 '0b1010'

 >>> bin(255)

 '0b11111111'

 chr()

 转换一个[0, 255]之间的整数为对应的ASCII字符

 >>> chr(65)

 'A'

 >>> chr(67)

 'C'

 >>> chr(90)

 'Z'

 >>> chr(97)

 'a'

 ord()

 将一个ASCII字符转换为对应整数

 >>> ord('A')

 65

 >>> ord('z')

 122

 16进制转10进制

 >>> int('', 16)

 16

 >>> int('0x10', 16)

 16

 8进制转10进制

 >>> int('0o10', 8)

 8

 >>> int('', 8)

 8

 2进制转10进制

 >>> int('0b1010', 2)

 10

 >>> int('', 2)

 10

 import sys

 sys.setrecursionlimit(100000)

 def foo(n):

     print(n)

     n += 1

     foo(n)

 if __name__ == '__main__':

     foo(1)

 写上面的东西的时候产生了一个疑问，现在已经知道Python内部存储str的方式是使用unicode字符集，但是我们在屏幕上看到的并不是unicode字符集

 s = "你好"

 print(s)

 #########output#############

 你好

 s的 unicode 是 \u4f60\u597d

 1

 那么，这中间应该是进行了某种转换

 实际上，在执行print(str)的时候，python内部执行了encoding操作，控制台拿到的其实是一个bytes变量

 之后，控制台又根据环境内部的编码方式，将所得到的bytes内容进行decoding的操作，就显示了原先str的内容

# encoding:utf-8

__author__ = 'Fioman'

__date__ = '2018/11/19 15:10'

# 1. 去掉空格和特殊符号

name = " abcdefgeyameng  "

name1 = name.strip()  # 并不会在原来的字符串上操作,返回一个去除了两边空白的字符串

print(name1, len(name1), name, len(name))

# abcdefgeyameng 14  abcdefgeyameng   17

# 去掉左边的空格和换行符

name2 = name.lstrip()

print(name2, len(name2))# print(name2, len(name2))#

# 去掉右边的空格和换行符

name3 = name.rstrip()

print(name3, len(name3)) # abcdefgeyameng 15

# 2.字符串的搜索和替换

name.count('e')  # 查找某个字符在字符串中出现的次数

name.capitalize() # 首字母大写

name.center(100,'-') # 把字符串方中间,两边用-补齐,100表示占位多少

name.find('a') # 找到这个字符返回下标,多个时返回第一个,不存在时返回-1

name.index('a') # 找到这个字符返回下标,多个时返回第一个,不存在时报错

print(name.replace(name,'')) # 字符串的替换

name.replace('abc','') # 注意字符串的替换的话,不是在原来的字符串上进行替换.而是返回一个替换后的字符串.

# 3.字符串的测试和替换函数

name.startswith("abc") # 是否以abc开头

name.endswith("def") # 是否以def结尾

name.isalnum() # 是否全是字母和数字,并且至少包含一个字符

name.isalpha() # 是否全是字母,并至少包含一个字符

name.isdigit() # 是否全是数字,并且至少包含一个字符

name.isspace() # 是否全是空白字符,并且至少包含一个字符

name.islower() # 是否全是小写

name.isupper() # 是否全是大写

name.istitle() # 是否是首字母大写

# 4.字符串的分割

name.split('') # 默认按照空格进行分隔,从前往后分隔

name.rsplit() # 从后往前进行分隔

# 5.连接字符串

'.'.join(name) # 用.号将一个可迭代的序列拼接起来

name = 'geyameng'

# 6.截取字符串(切片)

name1 = name[0:3] # 第一位到第三位的字符,和range一样不包含结尾索引

name2 = name[:] # 截取全部的字符

name3 = name[6:] # 截取第6个字符到结尾

name4 = name[:-3] # 截取从开头到最后一个字符之前

name5 = name[-1] # 截取最后一个字符

name6 = name[::-1] # 创造一个与原字符串顺序相反的字符串

name7 = name[:-5:-1] # 逆序截取

# encoding:utf-8

__author__ = 'Fioman'

__date__ = '2018/11/19 16:26'

# 1.创建一个列表

list1 = ['', '', '', '']

list2 = list("")

print(list1, list2)

print(list1 == list2)

# 以上创建的两个列表是等价的,都是['1', '2', '3', '4']

# 2.添加新元素

# 末尾追加

a = [1, 2, 3, 4, 5]

a.append(6)

print(a)

# 指定位置的前面插入一个元素

a.insert(2, 100)  # 在下标为2的前面插入一个元素100

print(a)

# 扩展列表list.extend(iterable),在一个列表上追加一个列表

a.extend([10, 11, 12])

print(a)

# 3.遍历列表

# 直接遍历

for i in a:

    print(i)

# 带索引的遍历列表

for index, i in enumerate(a):

    print(i, index)

# 4.访问列表中的值,直接通过下标取值.list[index]

print(a[2])

# 从list删除元素

# List.remove() 删除方式1:参数object 如果重复元素,只会删除最靠前的.

a = [1,2,3]

a.remove(2) # 返回值是None

# List.pop()  删除方式2:pop 可选参数index,删除指定位置的元素 默认为最后一个元素

a = [1,2,3,4,5]

a.pop()

print(a)

a.pop(2)

print(a)

# 终极删除,可以删除列表或指定元素或者列表切片,list删除后无法访问

a = [1,2,3,4,5,6]

del  a[1]

print(a) # 1, 3, 4, 5, 6]

del a[1:]

print(a) #

del a

# print(a) # 出错,name a is not defined

# 排序和反转代码

# reverse 反转列表

a = [1,2,3,4,5]

a.reverse()

print(a)

# sort 对列表进行排序,默认升序排列.有三个默认参数cmp = None,key = None,reverse = False

# 7.Python的列表的截取与字符串操作类型相同,如下所示

L = ['spam','Spam','SPAM!']

print(L[-1]) # ['SPAM']

# 8.Python列表操作的函数和方法

len(a)  # 列表元素的个数

max(a)  # 返回列表元素最大值

min(a)  # 返回列表元素最小值

list(tuple) #将一个可迭代对象转换为列表

# 列表常用方法总结

a.append(4)

a.count(1)

a.extend([4,5,6])

a.index(3)

a.insert(0,2)

a.remove()

a.pop()

a.reverse()

a.sort()

1.用一个可迭代对象生成元组

    T = tuple('abc')

对元组进行排序

注意

当对元组进行排序的时候,通常先得将它转换为列表并使得它成为一个可变对象.或者使用sorted方法,它接收任何序列对象.

T = ('c','a','d','b')

tmp = list(T)

tmp.sort()  ==> ['a','b','c','d']

T = tunple(tmp)

sorted(T)

以下实例展示了 fromkeys()函数的使用方法：

实例(Python 2.0+)

#!/usr/bin/python

# -*- coding: UTF-8 -*-

seq = ('Google', 'Runoob', 'Taobao')

dict = dict.fromkeys(seq)

print "新字典为 : %s" % str(dict)

dict = dict.fromkeys(seq, 10)

print "新字典为 : %s" % str(dict)

以上实例输出结果为：

新字典为 : {'Google': None, 'Taobao': None, 'Runoob': None}

新字典为 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}

通过zip函数构建字典

D = dict(zip(keyslist,valueslist))

通过赋值表达式元组构造字典(键必须是字符串,因为如果不是字符串,构造的时候也会当成是字符串处理)

D = dict(name='Bob',age=42)  ==> {'name':'Bob,'age':42}

列出所有的键,值.注意得到的是一个可迭代对象,而不是列表.用的时候需要转换

D.keys()

D.values()

D.items()  --> 键 + 值

删除字典(根据键)以及长度

D.pop(key)

len(D)

del D[key]

新增或者是修改键对应的值

D[key] = value  # 如果key已经存在则修改,如果不存在就创建.

字典推导式

D = [x:x**2 for x in range(10) if x %2 == 0]

list = lambda:x for x in range(10)

print (list[0])

>>>9

list = lambda x:x for x in range(10)

print (list[0])

>>>0

例子：

a = [('a',1),('b',2),('c',3),('d',4)]

a_1 = list(map(lambda x:x[0],a))

如上例子，map函数第一个参数是一个lambda表达式，输入一个对象，返回该对象的第一个元素。第二个就是需要作用的对象，此处是一个列表。Python3中map返回一个map对象，我们需要人工转为list，得到的结果就是[‘a’,’b’,’c’,’d’]

例子：

a = [1,2,3,4]

b = [2,3,4,5]

a_1 = list(map(lambda x,y:x+y,a,b))

上边这个例子是为了说明,lambda表达式参数可以是多个。返回结果是[3,5,7,9]

例子：

a = [1,2,3,4,5,6,7]

a_1 = filter(lambda x:x<4,a)

如上例子，定义lambda表达式，筛选a列表中小于4的元素，结果为[1,2,3]。filter函数直接返回一个列表，无需再进行转换，第三个是初始值，我们没给初始值，那么开始操作的两个元素就是序列的前两个。否则将使用我们给出的初始值和序列第一个元素操作，然后结果再与第三个元素操作，以此类推。上个例子结果是28

例子：

from functools import reduce #python3需要导入此模块

a = [1,2,3,4,5,6,7]

a_1 = reduce(lambda x,y:x+y,a)

reduce中使用的lambda表达式需要两个参数，reduce函数共三个参数，

第一个是就是lambda表达式，第二个是要累计的序列，第三个是初始值，

我们没给初始值，那么开始操作的两个元素就是序列的前两个。否则将使

用我们给出的初始值和序列第一个元素操作，然后结果再与第三个元素操

作，以此类推。上个例子结果是28

例子：

dict = {'a':1,'b':2,'c':3,'d':4,'e':3,'f':1,'g':7}

sorted_dict_asc = sorted(dict.items(),key=lambda item:item[0])

sorted_dict_dsc = sorted(dict.items(),key=lambda item:item[0],reverse=True)

输出（第一个升序，第二个降序）：

[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 3), ('f', 1), ('g', 7)]

[('g', 7), ('f', 1), ('e', 3), ('d', 4), ('c', 3), ('b', 2), ('a', 1)]]

定义函数时，使用*arg和**kwarg

*arg和**kwarg 可以帮助我们处理上面这种情况，允许我们在调用函数的时候传入多个实参

def exmaple2(required_arg, *arg, **kwarg):

    if arg:

        print "arg: ", arg

    if kwarg:

        print "kwarg: ", kwarg

exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo")

>> arg:  (1, 2, 3)

>> kwarg:  {'keyword2': 'foo', 'keyword1': 'bar'}

从上面的例子可以看到，当我传入了更多实参的时候

*arg会把多出来的位置参数转化为tuple

**kwarg会把关键字参数转化为dict

import copy

n1 = {'k1':'wu','k2':123,'k3':['alex',678]}

n2 = n1

import copy

n1 = {'k1':'wu','k2':123,'k3':['alex',678]}

n3 = copy.copy(n1)

import copy

n1 = {'k1':'wu','k2':123,'k3':['alex',678]}

n4 = copy.deepcopy(n1)

 for i in range(1,10):

     for j in range(1,i+1):

         print("%s * %s = %s" %(j,i,i*j),end="")

     print("")

print "\n".join("\t".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) for x in range(1, 10))

 1 import time

 2 import datetime


 print(time.asctime())      # 返回时间格式：Sun May  7 21:46:15 2017

 print(time.time())         # 返回时间戳 ‘1494164954.6677325’

 print(time.gmtime())       # 返回本地时间 的struct time对象格式，time.struct_time(tm_year=2017, tm_mon=5, tm_mday=7, tm_hour=22, tm_min=4, tm_sec=53, tm_wday=6, tm_yday=127, tm_isdst=0)

 print(time.localtime())    # 返回本地时间 的struct time对象格式，time.struct_time(tm_year=2017, tm_mon=5, tm_mday=7, tm_hour=22, tm_min=4, tm_sec=53, tm_wday=6, tm_yday=127, tm_isdst=0)

 print(time.gmtime(time.time()-800000))   # 返回utc时间的struc时间对象格式

 print(time.asctime(time.localtime()))    # 返回时间格式Sun May  7 22:15:09 2017

 print(time.ctime())                      # 返回时间格式Sun May  7 22:15:09 2017

 print(time.strftime('%Y-%m-%d'))         #默认当前时间 2017-05-07

 print(time.strftime('%Y-%m-%d',time.localtime())) #默认当前时间 2017-05-07

 string_struct = time.strptime("2016/05/22","%Y/%m/%d") # 将日期字符串 转成 struct时间对象格式

 print(string_struct)                     # 返回struct time对象格式 time.struct_time(tm_year=2016, tm_mon=5, tm_mday=22, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=143, tm_isdst=-1)

 # 将日期字符串转成时间戳

 struct_stamp = time.mktime(string_struct) # 将struct time时间对象转成时间戳

 print(struct_stamp)                         # 返回时间戳 ‘1463846400.0’

 # 将时间戳转为字符串格式

 print(time.gmtime(time.time()-86640))         # 将utc时间戳转换成struct_time格式

 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) # 将utc struct_time格式转成指定的字符串格式

 # 时间加减

 print(datetime.datetime.now())           # 返回当前时间 2017-05-07 22:36:45.179732

 print(datetime.date.fromtimestamp(time.time()))  # 时间戳直接转换成日期格式 2017-05-07

 print(datetime.datetime.now() + datetime.timedelta(3))    # 返回时间在当前日期上 +3 天

 print(datetime.datetime.now() + datetime.timedelta(-3))    # 返回时间在当前日期上 -3 天

 print(datetime.datetime.now() + datetime.timedelta(hours= 3)) # 返回时间在当前时间上 +3 小时

 print(datetime.datetime.now() + datetime.timedelta(minutes= 30)) # 返回时间在当前时间上 +30 分钟

 c_time  = datetime.datetime.now()

 print(c_time)                          # 当前时间为 2017-05-07 22:52:44.016732

 print(c_time.replace(minute=3,hour=2)) # 时间替换 替换时间为‘2017-05-07 02:03:18.181732’

 print(datetime.timedelta)      # 表示时间间隔，即两个时间点之间的长度

 print (datetime.datetime.now() - datetime.timedelta(days=5))  # 返回时间在当前时间上 -5 天

 # python 日历模块

 import calendar

 print(calendar.calendar(theyear= 2017))     # 返回2017年整年日历

 print(calendar.month(2017,5))               # 返回某年某月的日历，返回类型为字符串类型

 calendar.setfirstweekday(calendar.WEDNESDAY) # 设置日历的第一天(第一天以星期三开始）

 cal = calendar.month(2017, 4)

 print (cal)

 print(calendar.monthrange(2017,5))        # 返回某个月的第一天和这个月的所有天数

 print(calendar.monthcalendar(2017,5))     # 返回某个月以每一周为元素的序列

 cal = calendar.HTMLCalendar(calendar.MONDAY)

 print(cal.formatmonth(2017, 5))           # 在html中打印某年某月的日历

 print(calendar.isleap(2017))             # 判断是否为闰年

 print(calendar.leapdays(2000,2017))       # 判断两个年份间闰年的个数

 1 import random


 # 随机数

 print(random.random())              # 返回一个随机小数'0.4800545746046827'

 print(random.randint(1,5))          # 返回（1-5）随机整型数据

 print(random.randrange(1,10))       # 返回（1-10）随机数据

 # 生成随机验证码

 code = ''

 for i in range(4):

     current = random.randrange(0,4)

     if current != i:

         temp = chr(random.randint(65,90))

     else:

         temp = random.randint(0,9)

     code += str(temp)

 print(code)

import os

print(os.getcwd())        # 获得当前工作目录

print(os.chdir("dirname")) # 改变当前脚本的工作路径，相当于shell下的cd

print(os.curdir)            # 返回当前目录‘.'

print(os.pardir)            # 获取当前目录的父目录字符串名‘..'

print(os.makedirs('dirname1/dirname2'))     # 可生成多层递归目录

print(os.removedirs('dirname1/dirname2'))      # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

print(os.mkdir('test4'))         # 生成单级目录；相当于shell中mkdir dirname

print(os.rmdir('test4'))        # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

print(os.listdir('/pythonStudy/s12/test'))   # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

print(os.remove('log.log'))            # 删除一个指定的文件

print(os.rename("oldname","newname"))    # 重命名文件/目录)

print(os.stat('/pythonStudy/s12/test'))     # 获取文件/目录信息

print(os.pathsep)            # 输出用于分割文件路径的字符串';'

print(os.name)               # 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

print(os.system(command='bash'))   # 运行shell命令，直接显示

print(os.environ)                  # 获得系统的环境变量

print(os.path.abspath('/pythonStudy/s12/test'))   # 返回path规范化的绝对路径

print(os.path.split('/pythonStudy/s12/test'))     # 将path分割成目录和文件名二元组返回

print(os.path.dirname('/pythonStudy/s12/test'))    # 返回path的目录。其实就是os.path.split(path)的第一个元素

print(os.path.basename('/pythonStudy/s12/test'))   # 返回path最后的文件名。如果path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

print(os.path.exists('test'))                 # 判断path是否存在

print(os.path.isabs('/pythonStudy/s12/test'))    # 如果path是绝对路径，返回True

print(os.path.isfile('test'))                   # 如果path是一个存在的文件，返回True。否则返回False

print(os.path.isdir('/pythonStudy/s12/test'))    # 如果path是一个存在的目录，则返回True。否则返回False

print(os.path.getatime('/pythonStudy/s12/test'))   # 返回path所指向的文件或者目录的最后存取时间

print(os.path.getmtime('/pythonStudy/s12/test'))   # 返回path所指向的文件或者目录的最后修改时间

import sys

print(sys.argv)          # 命令行参数List，第一个元素是程序本身路径

print(sys.exit(n))     # 退出程序，正常退出时exit(0)

print(sys.version)       # 获取python的版本信息

print(sys.path)          # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

print(sys.platform)      # 返回操作平台的名称

# xml的格式如下，就是通过<>节点来区别数据结构的:
import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")

root = tree.getroot()

print(root.tag)

#遍历xml文档

for child in root:

    print(child.tag, child.attrib)

    for i in child:

        print(i.tag,i.text)

#只遍历year 节点

for node in root.iter('year'):

    print(node.tag,node.text)

# 修改和删除xml文档内容

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")

root = tree.getroot()

#修改

for node in root.iter('year'):

    new_year = int(node.text) + 1

    node.text = str(new_year)

    node.set("updated","yes")

tree.write("xmltest.xml")

#删除node

for country in root.findall('country'):

   rank = int(country.find('rank').text)

   if rank > 50:

       root.remove(country)

tree.write('output.xml')

# 自己创建xml文档

import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")

name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"})

age = ET.SubElement(name, "age", attrib={"checked": "no"})

age = ET.SubElement(name, "age")

age.text = ''

name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})

age = ET.SubElement(name2, "age")

age.text = ''

et = ET.ElementTree(new_xml)  # 生成文档对象

et.write("test.xml", encoding="utf-8", xml_declaration=True)

ET.dump(new_xml)  # 打印生成的格式

import logging

# %(message)s 日志信息

# %（levelno)s 日志级别

# datefmt  设置时间格式

# filename  设置日志保存的路径

# level=loggin.INFO意思是，把日志纪录级别设置为INFO，也就是说，只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里，

# 在这个例子， 第一条日志是不会被纪录的，如果希望纪录debug的日志，那把日志级别改成DEBUG就行了。

logging.basicConfig(format='%(asctime)s %(message)s %(levelno)s', datefmt='%m/%d/%Y %I:%M:%S %p',filename='example.log',level=logging.INFO)

logging.debug('This message should go to the log file')

logging.info('So should this')