001. Python初练之第一次接触

大部分情况, 单引号和双引号可以互换,但是如果字符串中包含了单引号, 则需要使用双引号

可以使用 \ 转义字符来处理

三引号是注释多行文本

注释: #  单行注释

“””    “””   多行注释

关于%s:

print ("%s %S %s" % ("a","b", "c"))
print ("%-15s+%20s+%10s" % ("55555","666666", "88888888"))
#输出结果  55555          +666666              +                      88888888

#格式说明符:  %s 是占位说明符→相当于C# 中的 {1} , 这个玩意
#			其中s必须是小写, 且%S的个数和 a  b  c  的个数必须保持一致
#			%10s 表示如果后面的 88888888 长度不够10个字符的话, 就会在88888888的右边(后面)补充2个空格; 如果够(或者超出, 则原样显示
#			%-15s 表示如果 55555的长度不够15个字符的还, 就会在55555的左边(前面)补充10个字符

#Python不能容纳太大的数字, 当超过Python的容纳范围, 将会给出inf的提示, inf是infinity(无穷大)的缩写

 关于%f:

print ("%.3f" % (4023-22.4))
#输出结果4000.600  三位小数

print ("%f" % (44/23))
#输出结果 1.000000   默认六位小数

print ("%0.f" % (44/23))
#输出结果1      相当于取整

print ("%0.f" % (10/3))
#输出结果3      相当于取整

print ("%5.f" % (44/23))
#输出结果    1 , 注意前面有4个空格

print ("十进制: %d,十六进制(小写): %x, 十六进制(大写):%X,八进制: %o" % (10,10,10,10))
#输出结果:  十进制: 10,十六进制(小写): a, 十六进制(大写):A,八进制: 12

 关于元组:

#Python中的元组就是数组
#定义数组
filler=("string", "int" , "long", "class", "object");

print ("%s,%s,%s,%s,%s" % filler)
#输出结果:string,int,long,class,object

print ("%s,%s,%s,%s,%s,%s" % filler)
#这样是会报错的

print (filler)
#输出结果 ('string', 'int', 'long', 'class', 'object')

#访问数组
print (filler[0])
#输出结果 string

#获得数组长度
print (len(filler))
#输出结果 5

#创建嵌套数组,在Python中如此简单. . .
filler2 = (filler, 1, 2, 3, 4, 5) #将filler直接嵌套到filler2中
print (filler2)
#输出结果(('string', 'int', 'long', 'class', 'object'), 1, 2, 3, 4, 5)

#通过filler2来访问filler的方式
print (filler2[0][0]) #输出结果应该是 string
#输出结果string

#数组的传递
filler3 = filler2[0]
print (filler3[0])
#输出结果string

#注意下面的两种创建方法
single_element_tuple=("string1",)
print ("类型: %s, 长度: %d" % (type(single_element_tuple),len(single_element_tuple)))

single_element_tuple=("string1")
print ("类型: %s, 长度: %d" % (type(single_element_tuple),len(single_element_tuple)))
#上面是创建数组, 后面有个逗号的
#下面是创建字符串,没有逗号
#输出结果分别是
'''类型: <type 'tuple'>, 长度: 1
类型: <type 'str'>, 长度: 7'''

 关于列表:

#列表和元组用法基本类似: 主要区别在于元组在创建后不可以被修改, 而列表任何时候都可以修改
#1. 元组使用 () 小括号 就是数组
#2. 列表使用 [] 中括号 相当于Arraylist
lunchfast = ("rice","apple","tomato")
breakfast = ["coffee","tea","egg","toast"]
count =1 ;
print (breakfast[0])
print (breakfast[count])

#列表修改值
breakfast[0]='hello'
print (breakfast[0])

'''
#元组修改值   这种操作方法会直接报错的, 元组的值一旦定义, 任何时候都不能修改
lunchfast[0]='haha'
print(lunchfast[0])
'''
#使用append方法, 向列表的末尾追加元素, append方法每次只能向列表的末尾增加一个元素
#使用extend方法, 一次性向列表末端添加多个元素, 比如添加一个元组或其它列表的内容, 添加的时候和元组是不一样的, 元组
#添加的时候是将被添加的元组作为一个整体加入; 而列表追加新的列表, 则是拷贝内容过来, 将被添加的列表中的
#每一个元素, 依次复制到新的列表中

breakfast.append("banana")

print (breakfast[4])
#输出结果 banana

breakfast.extend(lunchfast)  #追加元组
print (breakfast)
#输出结果  ['hello', 'tea', 'egg', 'toast', 'banana', 'rice', 'apple', 'tomato']

supper=["bread","butter","chicken","milk"]
breakfast.extend(supper)  #追加列表
print (breakfast)
#输出结果  ['hello', 'tea', 'egg', 'toast', 'banana', 'rice', 'apple', 'tomato', 'bread', 'butter', 'chicken', 'milk']

 关于字典:

#1. 元组使用 () 小括号 就是数组
#2. 列表使用 [] 中括号 相当于Arraylist
#3. 字典使用 {} 花括号创建, 使用名称索引
#创建空字典, 并使用字符串(名称)索引逐一赋值
menus_specials={}
menus_specials["breakfast"]="chicken";
menus_specials["lunch"] = "tuna"
menus_specials["dinner"] = "Cheess"


#一次性定义字典的键值对
#字典的工作原理是每个键都是不用的, 不可以有完全相同的两个键, 但是可以有多个重复的值
threemeals = {"breakfast":"chicken","lunch":"tuna","dinner":"Cheess"}
print (threemeals)
#输出结果 {'lunch': 'tuna', 'breakfast': 'chicken', 'dinner': 'Cheess'}
print ("%s" % threemeals["breakfast"])
#输出结果: chicken
#使用keys方法是字典返回所有的键, 使用value方法返回所有值, 使用get方法可以根据键来寻找值
hungry = threemeals.keys();
print (list(hungry))
#输出结果: ['lunch', 'breakfast', 'dinner']
str = threemeals.get("breakfast")
print (str)
#输出结果 chicken


#字典中不能有重复的键, 虽然在Python中不会报错, 但是前面的相同键的值, 会被后面的覆盖
#threemeals = {"breakfast":"chicken","breakfast":"chicken2","lunch":"tuna","dinner":"Cheess","dinner":"Cheess1"}
#hungry = threemeals.values();
#print (list(hungry))
#输出结果: ['tuna', 'chicken2', 'Cheess1']

处理字符串的技巧(使用 [][]):

#像列表一样处理字符串, 将字符串视为列表
last_name=["LucyAndHanMeimei", "LiLeiAndJim", "LilyAndTom", "YingWuAndPingGuoShu"]

print (last_name[0])
#输出结果 : LucyAndHanMeimei
print (last_name[0][0])
print (last_name[0][1])
print (last_name[1][0])
print (last_name[1][1])
'''输出结果:
L
u
L
i
'''
#根据字符串的字母顺序将字典中的元素以姓的首字母分组, 检查包含名字的字符串以那个字母开头, 并对此名字进行归档即可
#其实对姓名按照首字母排序使用字典, 并不是一个明智之举, 因为字典明显会将首字母相同的只显示最后一个名字
by_letter={}
#以
by_letter[last_name[0][0]] = last_name[0]
by_letter[last_name[1][0]] = last_name[1]
by_letter[last_name[2][0]] = last_name[2]
by_letter[last_name[3][0]] = last_name[3]

print (by_letter)
#输出结果: {'Y': 'YingWuAndPingGuoShu', 'L': 'LilyAndTom'} 很明显如果首字母相同, 则只显示最后一个L


print (last_name[-1])
#输出结果: YingWuAndPingGuoShu
print(last_name[0][-1])

使用[][] 分别测试元组/列表/字典

#1. 元组使用 () 小括号 就是数组
#2. 列表使用 [] 中括号 相当于Arraylist
#3. 字典使用 {} 花括号创建, 使用名称索引
#测试元组
slice_me=("The","next","time","we", "meet","drinks","are","on","me")

sliced_tuple = slice_me[5:9] #表示从第5个开始取, 取到第9个(包含), 取的时候下标从0开始
                            #但是后面的9, 所计算的下标则是从1开始. 好乱; 超过9则会报错
print (sliced_tuple)
#输出结果:('drinks', 'are', 'on', 'me')
sliced_tuple1 = slice_me[2:4]
print (sliced_tuple1)
#输出结果:('time', 'we')
#测试列表
slice_list=["The","next","time","we", "meet","drinks","are","on","me"]
sliced_this_list = slice_list[5:9]
print (sliced_this_list)
#输出结果:['drinks', 'are', 'on', 'me']
sliced_this_list1 = slice_list[2:4]
print (sliced_this_list1)
#输出结果: ['time', 'we']

#测试字符串
slice_str="The next time we meet, drinks are on me"
sliced_this_str = slice_str[5:9]
print (sliced_this_str)
#输出结果:ext
sliced_this_str1 = slice_str[2:4]
print (sliced_this_str1)
#输出结果: e

 处理集合和使用pop方法删除元素:

#使用pop方法删除元素
todays_temperatures=[23,32,33,31]
todays_temperatures.append(29)
print todays_temperatures

number = todays_temperatures.pop(1) #弹出并赋值
print todays_temperatures
#输出结果: [23, 33, 31, 29]
print number
#输出结果: 32

last_num = todays_temperatures.pop() #如果没有指定pop的参数, 则删除最后一个
print last_num

#处理集合: 集合两种类型: 可变集合和不可变集合(fromzenset)就像可变数组和不可变长度数组一样

alphabet = ['a','l','a','j','g','f','d','e','c','b']

print alphabet
#输出结果: ['a', 'l', 'a', 'j', 'g', 'f', 'd', 'e', 'c', 'b']
alph2 = set(alphabet)
print alph2
#输出结果:  set(['a', 'c', 'b', 'e', 'd', 'g', 'f', 'j', 'l']), 为什么会多了些set(). .