In [13]:

    

#引号互包含
print('hello')
print("'hello'")
print(""" "'print'" """)
print('"print"')
print('"""print"""')


    

    




hello
'hello'
 "'print'" 
"print"
"""print"""

In [14]:

    

print(' """ '"""hello"""' ')
print('\'dont\'t')


    

    




 """ hello 
'dont't

In [15]:

    

#"""可以用来输出多行文本"""
print('hello \
      ')

print("""1
2
3""")


    

    




hello       
1
2
3

In [16]:

    

#print可以输出连接字符,notebook和实际输出不同，cpython编译器输出hello world
print("hello","world")


    

    




('hello', 'world')

In [17]:

    

print("join %s%s"%("is"," boy")) 
print("join %%s%s"%("a"))  #如果想输出%s,则可以使用%%s
print("join \%%s%s"%("a")) #转意字符在这里无效


    

    




join is boy
join %sa
join \%sa

In [18]:

    

print("%d"%12)  #整数
print("%u"%11)  #无符号整形


    

    




12
11

In [19]:

    

# %5s表示输出有5个字符，如果没有那么在前面用空格填充
# 注意s要用小写
print("join%5s%5s"%("is","boy")) 
print('%6.2f'%1.235)   #长度为6，精确到小数点后两位


    

    




join   is  boy
  1.24

In [2]:

    

#两种格式化
print("%s,egg,and %s"%("a","b"))
print("{0},egg,and {1}".format('a','b'))


    

    




a,egg,and b
a,egg,and b

In [20]:

    

print(type(1))
print(type(1.))
print(type(1+2j))


    

    




<type 'int'>
<type 'float'>
<type 'complex'>

In [21]:

    

#当一个数达到python无法处理的时候，会返回inf
2e2222222222222222222222222203*111111111111111111111111111111111111111111111111111111111111111111111111111111


    

    
Out[21]:





inf

In [22]:

    

print(1*1.)
print(1+1.)
print(2/5)
print(2/5.)   #注意python中两个整形除非返回整形，会舍去小数点
print(5/3)
print(5%3)


    

    




1.0
2.0
0
0.4
1
2

In [23]:

    

print(5./3)
print("%.f"%(5./3))   
print("%.2f"%(5./3))  #保留后两位,注意python会在截断时四舍五入
print("%0.f"%(5./3))
print("%0.3f"%1.7777)


    

    




1.66666666667
2
1.67
2
1.778

In [24]:

    

#八进制和十六进制
print("%x"%10)
print("%X"%10)
print("%o"%10)
print("%O"%10) #不能使用大写


    

    




a
A
12






    




---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-24-54028ea81656> in <module>()
      3 print("%X"%10)
      4 print("%o"%10)
----> 5 print("%O"%10) #不能使用大写

ValueError: unsupported format character 'O' (0x4f) at index 1

In [25]:

    

#元组是一种不可更改的数据类型
a = () #创建空元组

a = ("11",(11,"11"),["11",[1]],{"aa":"bb"},set([1,2,3])) #元组中可以存放各种类型
print(a)

b = ("hello","world")
print("%s,%s"%b)

#当元组只有一个元素的时候，要在后面加逗号，不然会当成去掉括号后的类型
c = ("aa")
print(type(c))

c = ("aa",)
print(type(c))


    

    




('11', (11, '11'), ['11', [1]], {'aa': 'bb'}, set([1, 2, 3]))
hello,world
<type 'str'>
<type 'tuple'>

In [26]:

    

#对元组进行操作

#读取元组
print(a[0])
print(a[2][1])
print(a[3]["aa"])
print(a[0:1])
print(a[0:2])
print(a[0:])
print(a[-1])
print(a[:2])
print(a[:])


    

    




11
[1]
bb
('11',)
('11', (11, '11'))
('11', (11, '11'), ['11', [1]], {'aa': 'bb'}, set([1, 2, 3]))
set([1, 2, 3])
('11', (11, '11'))
('11', (11, '11'), ['11', [1]], {'aa': 'bb'}, set([1, 2, 3]))

In [27]:

    

#元组相加
a = (1,2)
b = (2,3)
c = a+b
print(c)


    

    




(1, 2, 2, 3)

In [28]:

    

#删除元组
a = (1,2)
print(a)
del a
print(a)


    

    




(1, 2)






    




---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-28-43ccfd1ea1da> in <module>()
      3 print(a)
      4 del a
----> 5 print(a)

NameError: name 'a' is not defined

In [29]:

    

#元组运算符
a = (1,2)
print(a*3)
print(len(a))
print("1" in a)
print(1 in a )


    

    




(1, 2, 1, 2, 1, 2)
2
False
True

In [30]:

    

#一些操作tuple的内置函数

#元组转换
print(tuple("aaasdf"))
print(tuple([1,2,3,[1,2]]))
print(tuple({"a":2,2:3}))
print(" ")


print(cmp((1,2),(2,3)))
print(cmp((1,2),(1,2)))
print(" ")


#元组(item>2) >字符>列表>字典>数值
print(max(1,2))
print(max(1,(1,2)))
print(max(1,(1,2),"zzzz"))
print(max(1,(1,2),"zzzz",{1:(1,2)}))
print(max(1,"zz",{1:2},[1,2]))
print(max(1,2,{1:2,3:3},"zzzz",(1,2),"aa"))


print(min(1,[2],(1)))


#比较元组内的元素
print(max((1,2)))
print(max((1,2,[1])))
print(max((1,2,[1],"a")))
print(max((1,2,[1],"a",(2))))
print(max((1,2,[1,2,2,2],"a",(2,2))))
print(max((1,2,[1,2,2,2],"a",(2,2),{1:(2,2)})))


    

    




('a', 'a', 'a', 's', 'd', 'f')
(1, 2, 3, [1, 2])
('a', 2)
 
-1
0
 
2
(1, 2)
(1, 2)
(1, 2)
zz
(1, 2)
1
2
[1]
a
a
(2, 2)
(2, 2)

In [31]:

    

#列表可以存放各种内置数据类型,并且可以增删查改
class a:
    def getName(self):
        print("i'm a")
b = [1,"2",[3,4],(5,6),{7:8,9:10},a,set([1,2,3])]
print(b)


    

    




[1, '2', [3, 4], (5, 6), {9: 10, 7: 8}, <class __main__.a at 0x00000000046F62E8>, set([1, 2, 3])]

In [32]:

    

#更改列表

a = [1,2,3,4]
print(a)

a.append(5)       #在末尾增加item
print(a)

a.pop()           #删除末尾item
print(a) 

a.insert(1,5)     #在位置1插入item
print(a)

a.pop(1)          #弹出位置1的item
print(a)

print(a.index(2)) #找到某元素的位置

a.reverse()       #翻转元素
print(a) 

a.sort()          #排序
print(a)

a.reverse()
b = sorted(a)     #不改变原列表的排序
print(a)
print(b)


    

    




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

In [33]:

    

a = [1,2]
print(a*3)
print(a+a)
print(a[-1])


    

    




[1, 2, 1, 2, 1, 2]
[1, 2, 1, 2]
2

In [34]:

    

a = [1,1,2,3,4,5]   #获取某元素在列表中出现的频率
print(a.count(1))
print(a.count(0))


    

    




2
0

In [35]:

    

#字典可以存放各种内置元素
a = {"1":1,"2":"1","3":[1,1],4:(1,1),5:{"1":1},6:set([1,2,3])}
print(a)

#键值不能为列表和字典,但是可以为元组
a = {(1,2,3):3}
print(a)

a = {{1:2}:2}   #wrong
a = {[1]:1}     #wrong


    

    




{4: (1, 1), 5: {'1': 1}, 6: set([1, 2, 3]), '1': 1, '3': [1, 1], '2': '1'}
{(1, 2, 3): 3}






    




---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-35-4ae75d644f10> in <module>()
      7 print(a)
      8 
----> 9 a = {{1:2}:2}   #wrong
     10 a = {[1]:1}     #wrong

TypeError: unhashable type: 'dict'

In [55]:

    

#读取字典
a = {"1":1,"2":"1","3":[1,1],4:(1,1),5:{"1":1},6:set([1,2,3])}

print(a['1'])
print(a[4])

print(a.get(4))   #返回键值4对应的值

print(a.keys())   #返回所有键值

print(a.values()) #返回所有键值对应的元素

print(a.items())  #返回元祖列表

b = a.copy()      #浅复制,复制引用而不是内存
print(b)

print(a.has_key(10))  #判读是否有10这个键值

b = {10:11}         #将a中的item更新到b中
b.update(a)  
print(b)


    

    




1
(1, 1)
(1, 1)
[4, 5, 6, '1', '3', '2']
[(1, 1), {'1': 1}, set([1, 2, 3]), 1, [1, 1], '1']
[(4, (1, 1)), (5, {'1': 1}), (6, set([1, 2, 3])), ('1', 1), ('3', [1, 1]), ('2', '1')]
{'1': 1, '3': [1, 1], '2': '1', 4: (1, 1), 5: {'1': 1}, 6: set([1, 2, 3])}
False
{'1': 1, '3': [1, 1], '2': '1', 4: (1, 1), 5: {'1': 1}, 6: set([1, 2, 3]), 10: 11}

In [37]:

    

#删除字典
aa = {1:1,2:2,3:3}
del aa[1]
print(aa)

aa.clear()                #清空，留下一个空字典
print(aa)

aa = {1:1,2:2,3:3}      
del aa                    #删除，将aa变量删除，所以显示aa没有定义
print(aa)


    

    




{2: 2, 3: 3}
{}






    




---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-37-8017998b9447> in <module>()
      9 aa = {1:1,2:2,3:3}
     10 del aa                    #删除，将aa变量删除，所以显示aa没有定义
---> 11 print(aa)

NameError: name 'aa' is not defined

In [38]:

    

#创建集合
a = set()
print(a)

a = [1,2,3,4]
set_a = set(a)
print(set_a)

a = (1,2,3,4)
set_a = set(a)
print(set_a)

a = (1,1,2,1,3,4)
set_a = set(a)
print(set_a)

a = set("aaabc")      #自动拆分
print(a)


a = ((1,2),1,2,1,3,4)  #Right
set_a = set(a)
print(set_a)

a = ([1,1],1,2,1,3,4)  #Wrong 列表是不可哈希类型
set_a = set(a)
print(set_a)


    

    




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






    




---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-38-6ceab0c4cca1> in <module>()
     24 
     25 a = ([1,1],1,2,1,3,4)  #Wrong 列表是不可哈希类型
---> 26 set_a = set(a)
     27 print(set_a)

TypeError: unhashable type: 'list'

In [39]:

    

#对集合进行操作
a = set()
print(a)

a.add("abc")        #add将添加元素看成整体
print(a)

a.update("abc")     #update将添加元素拆分
print(a)

a.update([1,2,3])   #update可以用来添加多个item
print(a) 

a.remove(1)         #删除元素
print(a)

print(a.pop())      #删除一个元素并返回删除的这个元素


    

    




set([])
set(['abc'])
set(['a', 'c', 'abc', 'b'])
set(['a', 1, 'c', 'abc', 3, 2, 'b'])
set(['a', 'c', 'abc', 3, 2, 'b'])
a

In [40]:

    

#两个集合的关系
a = set("abc")
b = set("ad")
print(a|b)         #并集/合集
print(a&b)         #交集
print(a-b)         #插集  a中有b中没有
print(a^b)         #对称插集
print(a in b)      #a是否是b的自己
print(a+b)         #wrong，集合中没有定义加号运算符


    

    




set(['a', 'c', 'b', 'd'])
set(['a'])
set(['c', 'b'])
set(['c', 'b', 'd'])
False






    




---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-40-9bb561f137cc> in <module>()
      7 print(a^b)         #对称插集
      8 print(a in b)      #a是否是b的自己
----> 9 print(a+b)         #wrong，集合中没有定义加号运算符

TypeError: unsupported operand type(s) for +: 'set' and 'set'

In [41]:

    

#小技巧，列表去重
list_a = [1,1,1,2,2,3]
print(list(set(list_a)))


    

    




[1, 2, 3]

In [42]:

    

a = "abcdef"
print(a[:-1])


    

    




abcde

In [43]:

    

#转义字符 \ 
print("abc\tde")

print(r"abc\tde")  #前面加r或者R保持字符不转移


    

    




abc	de
abc\tde

In [44]:

    

#操作字符串
a = "abcd" 
print(a.capitalize())         #大写第一个字符
print(a.upper())              #大写转换
print()


    

    




Abcd
ABCD
()

In [45]:

    

#一行没写完可以用\在下一行续写
print("abc \
efg")


    

    




abc efg

In [46]:

    

print("abc".find("d"))  #查找
print("abb".find("b"))
print("")

print("abc".index("c")) #查找，但是没找到会报错而不是返回-1
print("abc".index("d"))


    

    




-1
1

2






    




---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-46-2271846cbefc> in <module>()
      4 
      5 print("abc".index("c")) #查找，但是没找到会报错而不是返回-1
----> 6 print("abc".index("d"))

ValueError: substring not found

In [47]:

    

print("a".isalpha())    #如果全是字符则返回True
print("1abc".isalpha())
print("")

print("1abc".isalnum())  #如果只有字母和数字返回True
print("1abc'".isalnum()) #有其他符号返回False
print("")

print("012".isdigit())    #纯数字则返回True
print("a1".isdigit())
print("")

print("Aa".islower())     
print("aa".islower())
print("")

print("Aa".isupper())
print("AA".isupper())
print("")

print("a aaa".isspace())  #如果只包换空格则返回True
print("".isspace())
print(" ".isspace())
print("")


    

    




True
False

True
False

True
False

False
True

False
True

False
False
True

In [48]:

    

print(",".join("abcd"))  #按照,号将字符串隔开
print(" ".join("abcd"))
print(" ")

print("Abc".lower())
print("Abc".upper())
print("")

print("abcd".partition("a")) #按照规定字符分割字符串
print("abcd".partition("b"))
print(type("abcd".partition("b"))) #返回tuple类型
print("")

print("abcbd".split("b"))    #按照b分割，后面参数是分割次数
print("abcbd".split("b",1))  
print(type("abcbd".split("b",1))) #返回list类型
print("")

print("abA".swapcase())  #大小写反转
print("")


    

    




a,b,c,d
a b c d
 
abc
ABC

('', 'a', 'bcd')
('a', 'b', 'cd')
<type 'tuple'>

['a', 'c', 'd']
['a', 'cbd']
<type 'list'>

ABa

In [49]:

    

#小技巧，利用切片反转字符串
s = 'abcde'  
s[::-1]


    

    
Out[49]:





'edcba'

In [50]:

    

#ACSII编码
print(ord('A'))
print(chr(65))


    

    




65
A

In [51]:

    

#utf-8编码
print(u'汉语')


    

    




汉语

In [52]:

    

u'汉语'.encode('utf-8')


    

    
Out[52]:





'\xe6\xb1\x89\xe8\xaf\xad'

In [53]:

    

print('\xe6\xb1\x89\xe8\xaf\xad'.decode('utf-8'))


    

    




汉语

In [54]:

    

#如果源码中包含中文，那么应该在文件头注明下面代码
#告诉编译器按照utf-8编码对源代码进行读取
#！/usr/bin/env python          #linux专用，告诉系统这是可执行程序，Windows中不用
# -*- coding: utf-8 -*-         #告诉编译器按照utf-8编码对源代码进行读取


    

In [ ]: