码迷,mamicode.com
首页 > 编程语言 > 详细

Python入门一:基本数据类型

时间:2016-08-20 21:45:30      阅读:229      评论:0      收藏:0      [点我收藏+]

标签:


 

作为一个刚入门编程的大一狗,第一次写博客,希望能对自己学的知识进行巩固和提升,也希望记录自己成长的过程。

学习Python,一是因为暑假学的c++头疼,听说Python简单,那我就试试吧,二是因为Python形势一片大好,算是附和潮流吧!


 一、初识Python

1、第一个Python代码

1 print("Hello World")

 依然是熟悉的Hello World, 对于只学过c和c++的我来说,着实有点奇怪,怎么main()没了(其实是有的),头文件也没了,甚至连一句语句的末尾标识逗号也不见踪影。

2、概览

用下面一段猜大小的代码码来解释一下python与c(c++)的区别

c:

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<time.h>
 4 
 5 int main(void)
 6 {
 7     int try_num, true_num, x, count;
 8 
 9     while(1)
10     {
11         printf("请选择: 1.猜大小 2.退出: ");
12         scanf("%d", &x);
13         if(x == 2)
14             break;
15
srand(time(0)); 15 true_num = rand() % 100 + 1; 16 printf("请输入你猜的数字(1-100): "); 17 scanf("%d", &try_num); 18 count = 1; 19 while(try_num != true_num) 20 { 21 if(try_num >= 1 && try_num <= 100) 22 { 23 if(try_num > true_num) 24 printf("你猜大了!\n"); 25 else 26 printf("你猜小了!\n"); 27 } 28 else 29 printf("你输入的数字有误!\n"); 30 printf("请再次输入你猜的数字: "); 31 scanf("%d", &try_num); 32 count++; 33 } 34 printf("你终于猜对了, 共用了%d次.\n", count); 35 } 36 37 return 0; 38 }

Python:

 1 import random
 2 
 3 
 4 while True:
 5     x = int(input("请选择: 1.猜大小 2.退出: "))
 6     if x == 2:
 7         break
 8     true_num = random.randint(1, 100)
 9     try_num = int(input("请输入你猜的数字(1-100): "))
10     count = 1
11     while try_num != true_num:
13         if try_num in range(1, 101):
14             if try_num > true_num:
15                 print("你猜大了!")
16             else:
17                 print("你猜小了!")
18         else:
19             print("你输入的数字有误!")
20         try_num = int(input("请再次输入你猜的数字: "))
21         count += 1
22     print("你终于猜对了, 共用了%d次" % count)

 能清楚的看出,用Python写出的代码较c简洁美观,没有冗余,在语法上的几点区别总结如下:

  • 变量没有类型的声明,而是根据右侧表达式推断
  • 语句结尾没有分号
  • 循环语句和条件语句均以冒号标志其内部
  • 以缩进而不是大括号来区分作用域
  • ...

两者也具有高级语言的类似特点:

  • 都有条件语言,循环语言,判断语言等,大体用法相同,最大区别是in的使用,类似于c++11中的范围for
  • 都有基本的运算符,但是python增加了**,//,<>,去掉了逻辑运算符中的符号表达,全部由and,or,not等关键词表示
  • ...

 


二、基本数据类型

与c不同,Python的面向对象特征更加明显,连int,float等也有自己的方法;

与c++相比,Python的list,tuple,dict 等相较与STL的容器更容易使用,内置的方法也较丰富

1、int, float, complex

技术分享
 1 # int 方法
 2 def bit_length(self):
 3     pass
 4 # 返回该整数用二进制表示时的最小位数
 5 
 6 def __divmod__(self, *args, **kwargs):
 7     pass
 8 # 返回一个tuple, 包含两个元素,分别为self 与 argument相除的商和余数
 9 
10 
11 # float 方法
12 def as_integer_ratio(self):
13     pass
14 # 返回一个tuple, 即将float转化为分数形式
15 
16 def fromhex(self, string):
17     pass
18 # 返回16进制表示的string转化为的float
19 
20 def hex(self): 
21     pass
22 # 与fromhex()相反
23 
24 def is_integer(self, *args, **kwargs):
25     pass
26 # 返回 bool,判断float是否为整数
27 
28 
29 # complex 方法
30 def conjugate(self):
31     pass
32 # 返回复数的共轭复数
int, float,complex方法

 对于complex a, 可以通过a.real和a.imag使用其实部和虚部

2、bool: True, False

例如, 可以

1 a = True
2 while a:
3     # ...
4     if ...:
5         a = False

 3、str: 通过‘‘, "" 或 str()构建

技术分享
  1 def capitalize(self):
  2     pass
  3 # 返回str的首字母大写,其余小写的形式, str不变
  4 
  5 def casefold(self):
  6     pass
  7 # 返回str的所有字母变为小写的形式, str不变
  8 
  9 def center(self, width, fillchar=None):
 10     pass
 11 # 返回str居中,长度为width,左右以fillchar填充的形式,str不变
 12 
 13 def count(self, sub, start=None, end=None):
 14     pass
 15 # 返回str中[start, end)范围内sub的数目
 16 
 17 def endswith(self, suffix, start=None, end=None): 
 18     pass
 19 # 返回str的[start, end) 子序列是否以suffix结尾
 20 
 21 def expandtabs(self, tabsize=8):
 22     pass
 23 # 返回str的所有tab变成tabsize长度的空格, str不变
 24 
 25 def find(self, sub, start=None, end=None):
 26     pass
 27 # 返回str的[start, end) 范围内sub的位置, 未找到返回-1
 28 
 29 def rfind(self, sub, start=None, end=None): 
 30     pass
 31 # 与find()不同的是从右向左
 32 
 33 def format(self, *args, **kwargs):
 34     pass
 35 # 返回str的格式化的字符串, 使用{}而非%,str不变
 36 
 37 def index(self, sub, start=None, end=None):
 38     pass
 39 # 返回str的[start, end) 子序列的sub所在的下标, 未找到报错
 40 
 41 def rindex(self, sub, start=None, end=None): 
 42     pass
 43 # 与index()不同的是从右向左
 44 
 45 def isalnum(self): 
 46     pass
 47 # 返回str是否全部由字母和数字构成
 48 
 49 def isalpha(self):
 50     pass
 51 # 返回str是否全部由字母构成
 52 
 53 def isdigit(self):
 54     pass
 55 # 返回str是否全部由数字构成
 56 
 57 def islower(self):
 58     pass
 59 # 返回str是否所有字母都是小写
 60 
 61 def isupper(self):
 62     pass
 63 # 返回str是否所有字母都是大写
 64 
 65 def isspace(self):
 66     pass
 67 # 返回str是否全部由空白字符构成
 68 
 69 def istitle(self):
 70     pass
 71 # 返回是否所有单词都是大写开头
 72 
 73 def join(self, iterable):
 74     pass            
 75 # 返回通过指定字符str连接序列iterable中元素后生成的新字符串
 76 
 77 def ljust(self, width, fillchar=None): 
 78     pass
 79 # 返回str左对齐,不足width的以fillchar填充, str不变
 80 
 81 def rjust(self, width, fillchar=None): 
 82     pass
 83 # 返回str右对齐,不足width的以fillchar填充, str不变
 84 
 85 def lower(self):
 86     pass
 87 # 返回str全部小写的拷贝, str不变
 88 
 89 def upper(self):
 90     pass
 91 # 返回str全部大写的拷贝, str不变
 92 
 93 def swapcase(self): 
 94     pass
 95 # 返回str全部大小写交换的拷贝, str不变
 96 
 97 def strip(self, chars=None):
 98     pass
 99 # 返回str移除左右两侧所有chars的拷贝,str不变
100 
101 def lstrip(self, chars=None): 
102     pass
103 # 返回str移除左侧所有chars的拷贝,str不变
104 
105 def rstrip(self, chars=None):
106     pass
107 # 返回str移除右侧所有chars的拷贝,str不变
108 
109 def partition(self, sep):
110     pass
111 # 返回str以sep分割的前,sep,后部分构成的tuple,
112 # 未发现返回sep和两个空字符构成的tuple
113 
114 def rpartition(self, sep):
115     pass
116 # 和partition()不同的是从右向左
117 
118 def replace(self, old, new, count=None):
119     pass
120 # 返回str把count数目的old替换为new的拷贝,str不变
121 
122 def split(self, sep=None, maxsplit=-1):
123     pass
124 # 返回一个以sep分隔str的maxsplit(默认最大)的list,str不变
125 
126 def rsplit(self, sep=None, maxsplit=-1):
127     pass
128 # 和split()不同的是从右向左
129 
130 def splitlines(self, keepends=None):
131     pass
132 # 返回一个以\n或\r或\r\n分隔的list,若keepends=true,保留换行
133 
134 def startswith(self, prefix, start=None, end=None):
135     pass
136 # 返回str的[start, end)范围内是否以prefix开头
137 
138 def title(self):     
139     pass
140 # 返回所有单词是大写开头的拷贝,str不变
141 
142 def zfill(self, width):
143     pass
144 # 返回str的以width为长度,不够左侧补0的拷贝(不会截短),str不变
145 
146 def maketrans(self, *args, **kwargs):
147     pass
148 # 返回生成的一个翻译表,与translate()搭配使用
149 
150 def translate(self, table): 
151     pass
152 # 根据maketrans()生成的table来翻译str,返回拷贝,str不变
str方法

 a.对str中的方法的总结:

  • 大小写,空格与table,特定格式等的转化,替换: capitalize,casefold,expandtabs,format,lower,upper,swapcase,replace,title,maketrans,translate
  • 填充与移除字符串,连接与分隔字符串: center,strip,lstrip,rstrip,join,ljust,rjust,partition,rpartition,split,rsplit,splitlines,zfill
  • 子序列数目,位置:count,find,rfind,index,rindex
  • 判断字母,数字,大小写,空格,开头,结尾 :endswith,isalnum,isalpha,isdigit,islower,isupper,isspace,istitle,startswith
  • 和左右扫描方向有关的方法一般还包括一个r__()方法,表示从右向左扫描
  • 所有方法均不改变str,只是返回一个拷贝或bool

b.几个方法详解:

  • format:
 1 # 通过位置
 2 string1 = "{0} is the most {1} teacher of life"
 3 str1 = string1.format("Suffering", "powerful")
 4 # str1 = "Suffering is the most powerful teacher of life"
 5 string2 = "{0}, {1}, {0}"
 6 str2 = string2.format("Edward", "Tang"}
 7 # str2 = "Edward, Tang, Edward"
 8 
 9 # 通过关键词
10 string = "{name} is  {age}"
11 str = string.format(name="Edward", age=19)
12 # str = "Edward is 19"
13 
14 # 填充和对齐
15 # ^、<、>分别是居中、左对齐、右对齐,后面带宽度
16 # :号后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充
17 string1 = "{: >6}"
18 str1 = string1.format("Ed")
19 # str1 = "    Ed"
20 string2 = "{:*<6}"
21 str2 = string2.format("Ed")
22 # str2 = "Ed****"
23 
24 # 控制精度
25 string = “{:.2f}”
26 str1 = string.format(3.1415926)
27 # str1 = "3.14"
28 
29 # 金额分隔符
30 string = "{:,}"
31 str = string.format(1234567)
32 # str = "1,234,567"
  •  maketrans和translate:
1 # s.maketrans(‘s1‘, ‘s2‘) s1 和 s2 的长度必须一致,生成一个转换表
2 # s.translate(table) 对字符串s按照table里的字符映射关系替换
3 s = "I was a handsome boy"
4 table = s.maketrans("abcde", "12345")
5 str = s.translate(table)
6 # str = "I w1s 1 h1n4som5 2oy"
  •  join和split:
 1 # join用于用指定str连接参数的str序列
 2 lst = [a, b, c, d]
 3 s = -.join(lst)
 4 # s = "a-b-c-d"
 5 
 6 def accum(s):
 7     return -.join(c.upper() + c.lower() * i for i, c in enumerate(s))
 8 # s = "abcd",返回 “A-Bb-Ccc-Dddd”
 9 
10 # split用于用指定参数拆分str
11 s = "a-b-c-d"
12 lst = s.split(-)
13 # lst = [‘a‘, ‘b‘, ‘c‘, ‘d‘]

 c.索引和切片:

Python中的索引和C类似,但是可以从右边开始:

1 word = "python"
2 # word[0] = ‘p‘
3 # word[5] = ‘n‘
4 # word[-1] = ‘n‘, 表示最后一个, -0和0一样

 除了索引, 还支持切片:

1 word = "python"
2 # word[0: 2] = ‘py‘
3 # word[2: 5] = ‘tho‘
4 # word[: 2] = ‘py‘, 等同于[0: 2]
5 # word[3:] = ‘hon‘, 等同于[3: len(word)]

 切片和c++中的迭代器类似,都是为单闭合区间;

切记str是const的, 不可以通过赋值等改变它们

4、list:通过[]或list()构建

技术分享
 1 def append(self, p_object):
 2     pass
 3 # 添加元素p_object到list末尾,p_object可以是任何类型
 4 
 5 def clear(self):
 6     pass
 7 # 清空list中的元素
 8 
 9 def copy(self):
10      pass
11 # 返回一个list的浅拷贝
12 
13 def count(self, value):
14     pass
15 # 返回list中的value的个数
16 
17 def extend(self, iterable)
18     pass
19 # 添加整个iterable到list末尾,扩展list
20 
21 def index(self, value, start=None, stop=None):
22     pass
23 # 返回子序列[start, stop)中value第一次出现的下标,未找到报错
24 
25 def insert(self, index, p_object):
26     pass
27 # 插入一个p_object到下标为index的元素之前
28 
29 def pop(self, index=None):
30     pass
31 # 弹出index位置的元素并返回此元素, list为空或index超出范围会报错
32 
33 def remove(self, value):
34     pass
35 # 清除list中第一个值为value的元素,不返回此值
36 
37 def reverse(self):
38     pass
39 # 反转整个list
40 
41 def sort(self, key=None, reverse=False):
42     pass
43 # 排序list,key可以为lambda或cmp,reverse为True需要反转
list方法

 a.对list中方法的总结:

  • 添加:append, extend, insert
  • 删除:clear, pop, remove
  • 搜素:count, index
  • 拷贝:copy
  • 排序:sort
  • 反转:reverse
  • 与str不同,list中元素大都直接修改list,返回None而不是拷贝

b.几个方法详解:

  • append和extend:
1 lst = [1, 5, 4, 3, 8]
2 lst.append(3) 
3 # lst = [1, 5, 4, 3, 8, 3]
4 lst.append([1, 2, 3]) 
5 # lst = [1, 5, 4, 3, 8, 3, [1, 2, 3]],始终把参数当做一个元素
6 lst.extend([1, 2, 3])
7 #[1, 5, 4, 3, 8, 3, [1, 2, 3], 1, 2, 3],合并为一个list

 c.索引和切片:

与str基本一致,但是由于list可变,还存在一个del语言:

1 lst = [3, 4, 5, 6, 7]
2 del lst[0]
3 # lst = [4, 5, 6, 7]
4 del lst[1:3]
5 # lst = [4, 7]
6 del lst[:]
7 # lst = []

 5.tuple:通过()或tuple()构建(括号可以省略), 只包含一个元素时,在元素后面添加逗号

技术分享
def count(self, value):
    pass
# 返回tuple中value的个数

def index(self, value, start=None, stop=None):
    pass
# 返回子序列[start, stop)中第一个值为value的下标
tuple方法

tuple和list的区别在于其不能改变,所有很多方法没有

tuple也有索引和切片,不再赘述

要想对tuple进行强制修改,可以通过list()构造

6.dict:通过{}或dict()构建

技术分享
 1 def clear(self): 
 2     pass
 3 # 清空dict中的元素
 4 
 5 def copy(self):
 6     pass
 7 # 返回dict的一个拷贝
 8 
 9 def fromkeys(*args, **kwargs):
10     pass
11 # 返回一个dict,所有的key都对应同一个value(默认为None)
12 
13 def get(self, k, d=None):
14     pass
15 # 返回key为k时对应的value,如果不存在,返回d
16 
17 def setdefault(self, k, d=None):
18     pass
19 # 返回key为k时对应的value,如果不存在,添加一个k: d
20 
21 def items(self): 
22     pass
23 # 返回dict中所有key, value构成的dict_items()
24 
25 def keys(self):
26     pass
27 # 返回dict中所有key构成的dict_keys()
28 
29 def values(self):
30     pass
31 # 返回dict中所有value构成的dict_values()
32 
33 def pop(self, k, d=None):
34     pass
35 # 弹出dict中k所对应的value,没找到返回d
36 
37 def popitem(self):
38     pass
39 # 随机弹出dict中一个(key, value),dict为空时出错
40 
41 def update(self, E=None, **F):
42     pass
43 # 用另一个dict F 来更新原dict, 返回None
dict方法

 a.对dict中方法的总结:

  • 添加:直接用dic[key] = value即可添加
  • 删除:clear, pop, popitem
  • 查找, 引用:get, setdefault, items, keys, values
  • 构建:copy, fromkeys, update
  • 与list类似,但由于是无序的,所有没有下标的操作,且popitem弹出的元素也是随机的

b.几个方法详解:

  • pop和popitem: 
1 dic = {k1: v1, k2: v2, k3: v3}
2 # key为str的构建时也可以写成 dic = dict(k1 = ‘v1‘, k2 = ‘v2‘, k3 = ‘v3)
3 k = dic.pop(k1)
4 # k = ‘v1‘且 dic = {‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘}
5 item = dic.popitems()
6 # item = (‘k2’, ‘v2‘)或(‘k3‘, v3‘) 因为dic是无序的,且dic会随之变化
  •  get和setdefault: 
1 dic = {k1: v1, k2: v2, k3: v3}
2 s1 = get(k1)  # s1 = dic[‘k1‘]
3 s2 = get(k4, v4)  # s2 = ‘v4‘
4 s1 = setdefault(k1)  # s1 = dic[‘k1‘]
5 s2 = setdefault(k4, v4)  # dic[‘k4‘] = ‘v4‘
  •  items, keys, values:
1 dic = {k1: v1, k2: v2, k3: v3}
2 for k in dic.keys():
3     print(k) 
4 for v in dic.values():
5     print(v)
6 for k, v in dic.items():
7     print(k, v)
8 # 分别输出了dic中所有的key, value和键值对
  •  fromkeys和update:
 1 # fromkeys第一个参数可以是任意类型的序列,
 2 # 第二个参数为空默认value都为None
 3 dic = dict.fromkeys((k1, k2, k3))
 4 # dic = {‘k2‘: None, ‘k1‘: None, ‘k3‘: None}
 5 dic = dict.fromkeys((k1, k2, k3), 520)
 6 # dic = {‘k2‘: 520, ‘k3‘: 520, ‘k1‘: 520}
 7 
 8 # update将dic1更新, 返回None
 9 dic1 = {k1: 13, k2: 14, k3: 520}
10 dic2 = {k4: Edward, k3: 250}
11 dic = dic1.update(dic2)
12 # dic = None
13 # dic2 = {‘k1‘: 13, ‘k2‘: 14, ‘k3‘: 250, ‘k4‘: ‘Edward‘}

7.set:通过set()构建

技术分享
 1 def add(self, *args, **kwargs):
 2     pass
 3 # 向set中添加一个元素,返回None
 4 
 5 def clear(self, *args, **kwargs):
 6     pass
 7 # 清空set中的元素
 8 
 9 def copy(self, *args, **kwargs):
10     pass
11 # 返回一个set的浅拷贝
12 
13 def difference(self, *args, **kwargs):
14     pass
15 # 返回一个set,其中不含参数集合中的元素,差集
16 
17 def difference_update(self, *args, **kwargs): 
18     pass
19 # 和difference()相比,set自身更新为差集,返回None
20 
21 def symmetric_difference(self, *args, **kwargs):
22     pass
23 # 返回集合之间的对称差集
24 
25 def symmetric_difference_update(self, *args, **kwargs):
26     pass
27 # 和symmetric_difference()相比,set自身更新为对称差集,返回None
28 
29 def intersection(self, *args, **kwargs):
30     pass
31 # 返回set和参数集合的交集
32 
33 def intersection_update(self, *args, **kwargs):
34     pass   
35 # 和intersection()相比,set自身更新为交集,返回None
36 
37 def union(self, *args, **kwargs):
38     pass
39 # 返回set和参数集合的并集 
40   
41 def update(self, *args, **kwargs):
42     pass
43 # 和union()相比,set自身更新为并集,返回None
44 
45 def discard(self, *args, **kwargs):
46     pass
47 # 清除set中的参数元素,返回None, 若没有不做任何事,
48 
49 def isdisjoint(self, *args, **kwargs):
50     pass
51 # 返回集合之间是否交集为空
52 
53 def issubset(self, *args, **kwargs):
54     pass
55 # 返回是否set为参数集合的子集
56 
57 def issuperset(self, *args, **kwargs):
58     pass    
59 # 返回是否set为参数集合的父集
60 
61 def pop(self, *args, **kwargs):
62     pass
63 # 弹出set中一个随机的值并返回,set为空会出错
64 
65 def remove(self, *args, **kwargs):
66     pass
67 # 清除set中的参数元素,返回None,没有会出错
set方法

 a.对set中方法的总结:

  • 差集,交集,并集运算:difference, difference_update, symmetric_difference, symmetric_difference_update, intersection, intersection_update, union, update
  • 添加元素:add
  • 删除元素:clear, discard, remove, pop
  • 拷贝:copy
  • 判断空集,父集,子集:isdisjoint, issubset, issuperset
  • 集合间的运算都有两个版本,分别直接在原set上操作和返回一个拷贝
  • 与dict相比,没有key,也是无序的,所有没有下标操作,pop也是随机弹出元素

b.集合的运算符:

a, b, c均为集合
差集:c = a - b 等同于 c = a.difference(b)
     a -= b 等同于 a.difference_update(b)
对称差集:c = a ^ b 等同于 c = a.symmetric_difference(b)
        a ^= b 等同于 a.symmetric_difference_update(b)
交集:c = a & b 等同于 c = a.intersection(b)
     a &= b 等同于 a.intersection_update(b)
并集:c = a | b 等同于 c = a.union(b)
     a |= b 等同于 a.update(b)
判断子集: a <= b 等同于 a.issubset(b)
判断父集: a >= b 等同于 a.issupperset(b)

 

Python入门一:基本数据类型

标签:

原文地址:http://www.cnblogs.com/EdwardTang/p/5786007.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!