琪齐

空想终日彷徨行动方可无惧!

导航

编码转换、运算符和基本数据类型

Posted on 2016-05-02 22:26  琪齐  阅读(364)  评论(0编辑  收藏  举报

编码转换:

 

 

 

示例:

#这是python2.7中

#_*_ coding:utf-8 _*_
temp = "你好,世界" # utf-8
#解码,需要指定原来是什么编码
temp_unicode = temp.decode("utf-8")

#编码,需要指定原来是什么编码
temp_gbk = temp_unicode.encode("gbk") 

print(temp_gbk)


#在python 3中

temp = "你好,世界"

temp_gbk = temp.encode("gbk")

print(temp_gbk)

 

 

 

 

运算符

1,算数运算:

  假设变量a持有10和变量b持有20,则:

运算符                     描述      实例
+ 加法 - 对操作符的两侧加值 a + b = 30
- 减法 - 从左侧操作数减去右侧操作数 a - b = -10
* 乘法- 相乘运算符两侧的值 a * b= 200
/ 除 - 由右侧操作数除以左侧操作数 b / a = 2
% 模 - 由右侧操作数和余返回除以左侧操作数 b % = 0
** 指数- 执行对操作指数(幂)的计算 a**b = 10 幂为 20
// 地板除 - 操作数的除法,其中结果是将小数点后的位数被除去的商。 9//2 = 4 而 9.0//2.0= 4.0

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 实例:

 

 

#!/usr/bin/python

a = 20
b = 10
c = 0

c = a + b
print "w1 ", c

c = a - b
print "w2 ", c

c = a * b
print "w3 ", c

c = a / b
print "w4 ", c

c = a % b
print "w5 ", c

a = 2
b = 3
c = a**b
print "w6 ", c

a = 10
b = 5
c = a//b
print "w7 ", c

运算结果:

w1 30
w2 10
w3 200
w4 2
w5 0
w6 8
w7 2

 

 

 

 

 

 

2,比较运算

   假设变量a持有10和变量b持有20,则:

  运算符     描述    示例
==      检查两个操作数的值是否相等,如果是,则条件变为真。 (a == b) 不为 true.
!= 检查两个操作数的值是否等相等,如果值不相等,则条件变为真。 (a != b) 为 true.
<> 检查两个操作数的值是否等相等,如果值不相等,则条件变为真。 (a <> b) 结果为true。这类似于!=运算符。
> 检查左操作数的值是否大于右操作数的值,如果是,则条件成立。 (a > b) 为  true.
< 检查左操作数的值是否小于右操作数的值,如果是,则条件成立。 (a < b) 为true.
>= 检查左操作数的值是否大于或等于右操作数的值,如果是,则条件成立。 (a >= b) 不为 true.
<= 检查左操作数的值是否小于或等于右操作数的值,如果是,则条件成立。 (a <= b) 为 true.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

实例:

 

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3 
 4 a = 20
 5 b = 10
 6 c = 0
 7 
 8 if ( a == b ):
 9    print "e1 等于 b"
10 else:
11    print "e1 不等于 b"
12 
13 if ( a != b ):
14    print "e2 不等于 b"
15 else:
16    print "e2 等于 b"
17 
18 if ( a <> b ):
19    print "e3 不等于 b"
20 else:
21    print "e3 等于 b"
22 
23 if ( a < b ):
24    print "e4 小于 b"
25 else:
26    print "e4 大于等于 b"
27 
28 if ( a > b ):
29    print "e5 大于 b"
30 else:
31    print "e5 小于等于 b"
32 
33 
34 if ( a <= b ):
35    print "e6 小于等于 b"
36 else:
37    print "e6 大于  b"
38 
39 if ( b >= a ):
40    print "e7 大于等于 b"
41 else:
42    print "e7 小于 b"
43 
44 运算结果:
e1 不等于 b
e2 不等于 b
e3 不等于 b
e4 大于等于 b
e5 大于 b
e6 大于  b
e7 小于 b

 

 

 

 

 

 

 

3,赋值运算 
运算符    描述 示例
= 简单的赋值运算符,赋值从右侧操作数左侧操作数 c = a + b 类似于 a + b 到 c
+= 添加和赋值操作符,它增加了右操作数左操作数和结果赋给左操作数 c += a 类似于 c = c + a
-= 减和赋值操作符,它减去右边的操作数从左边操作数,并将结果赋给左操作数 c -= a 类似于 c = c - a
*= 乘法和赋值操作符,它乘以右边的操作数与左操作数,并将结果赋给左操作数 c *= a 类似于 c = c * a
/= 除和赋值操作符,它把左操作数与正确的操作数,并将结果赋给左操作数 c /= a 类似于 c = c / a
%= 模量和赋值操作符,它需要使用两个操作数模和结果赋给左操作数 c %= a 类似于 c = c % a
**= 指数和赋值运算符,执行指数(幂)计算操作符和赋值给左操作数 c **= a 类似于 c = c ** a
//= 地板除,并分配一个值,执行地板划分对操作和指定值到左操作数 c //= a 类似于 c = c // a

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

实例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 20
b = 10
c = 0

c = a + b
print "q1的值为:", c

c += a
print "q2的值为:", c

c *= a
print "q3的值为:", c

c /= a
print "q4的值为:", c

c = 2
c %= a
print "q5的值为:", c

c **= a
print "q6的值为:", c

c //= a
print "q7的值为:", c

运算结果:
q1的值为: 30
q2的值为: 50
q3的值为: 1000
q4的值为: 50
q5的值为: 2
q6的值为: 1048576
q7的值为: 52428
 

 

 

 

 

 

4,逻辑运算

   假设变量a持有10和变量b持有20:

运算符     
    描述     例子
  and 所谓逻辑与运算符。如果两个操作数都为真,则条件为真。 (a and b) 为 true.
   or 所谓逻辑OR运算符。如果有两个操作数都为非零,则条件变为真。 (a or b) 为 true.
   not 所谓逻辑非运算符。用反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将为false。 not(a and b) 为 false.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

实例:

a = 10
b = 20

if ( a and b ):
   print " a 和 b 都为 true"
else:
   print " a 和 b 有一个不为 true"

if ( a or b ):
   print " a 和 b 都为 true,或其中一个变量为 true"
else:
   print " a 和 b 都不为 true"

# 修改变量 a 的值
a = 0
if ( a and b ):
   print " a 和 b 都为 true"
else:
   print " a 和 b 有一个不为 true"

if ( a or b ):
   print " a 和 b 都为 true,或其中一个变量为 true"
else:
   print " a 和 b 都不为 true"

if not( a and b ):
   print " a 和 b 都为 false,或其中一个变量为 false"
else:
   print " a 和 b 都为 true"

运算结果:
 a 和 b 都为 true
 a 和 b 都为 true,或其中一个变量为 true
 a 和 b 有一个不为 true
 a 和 b 都为 true,或其中一个变量为 true
 a 和 b 都为 false,或其中一个变量为 false
 

 

 

 

 

 

 

 

 5,成员运算

 

运算符                  描述         实例
      in 如果在指定的序列中找到值返回 True,否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
  not in 如果在指定的序列中没有找到值返回 True,否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

实例: 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

a = 10
b = 20
list = [1, 2, 3, 4, 5 ];

if ( a in list ):
   print "a 在给定的列表中 list 中"
else:
   print "a 不在给定的列表中 list 中"

if ( b not in list ):
   print "b 不在给定的列表中 list 中"
else:
   print "b 在给定的列表中 list 中"

# 修改变量 a 的值
a = 2
if ( a in list ):
   print "a 在给定的列表中 list 中"
else:
   print "a 不在给定的列表中 list 中"

运算结果:
a 不在给定的列表中 list 中
b 不在给定的列表中 list 中
a 在给定的列表中 list 中
 

 

 

Pychorm 的设置

 

1,模板

file => settings =>Editor => file and code template => python script =>右上方

   #!/usr/bin/env python

   # _*_ coding:utf-8 _*_

按OK确定   

 

 

2,文字大小

file => settings =>Editor => color and font =>font =>save as ... =>14

 

 

3,运行(3种方法)

    a,点击运行文件,右键 rum

     b,view => tooldar

        选中要执行的文件

        点击 运行

      c,在当前文件空白处,右键,rum

 

4,切换py版本

 

file => settings =>project interpreter => 选择版本

 

 

 

基本数据类型

1,数字

整型(Int) -    通常被称为是整型或整数,是正或负整数,不带小数点。

 

1,
n1 = 123
n2 = 456
print(n1 + n2)     #print(n1._add_(n2)) 这是内部执行的
2,
n1 = 4
ret = n1.bit_length()  #获取数字在二进制中的最短位数 
print(ret)

 

2,字符串(str)

1capitalize  首字母变大写
示例:
a1 = "alex"
ret = a1.capitalize()
print(ret)

2,center 让字符串居中
示例: a1
= "alex" a1.center(10,"*") print(ret) 3,count 在子 字符串中出现几个 a1 = "alex is alph" ret = a1.count("a1") print(ret) a1 = "alex is alph" ret = a1.count("a1",0,8) print(ret) 4,endswith 是否以什么结尾 示例:
temp
= "hello" print(temp.endswith("o")) 5,expandtads 一个tab换成8个空格 示例:
content
= ("hello\t999") print(content.expandtads()) print(content.expandtads(20)) 6,find 能找到就到那个位子,没找到就返回一个-1 示例:
s
= "alex hello" print(s.find("p") 7,format 字符串的格式化 示例:
s
= "hello {0}, age {1}" print(s) # {0} 占位符 new1 = s.format("alex", 19) print(new1) 运算结果: hello {0}, age {1} hello alex, age 19 8,index获取子序列的位子,如果没找到就报错 示例:
s
= "alex hello" print(s.index("p") 9,isalnum 判断字符串是否是字母和数字 #接self表示不用添加参数 示例:
a = "alex5" a.isalnum()
10,isalpha 是否是字母
11,iadigit 是否是数字 12,islower 是否是小写
13,title 变成标题 示例:
s
= "the schol" ret = s.title() print(ret) 运算结果: The School 14,istitle 是否是标题
15,isupper 检验是否全部是大写 16,join 用
**连接 示例:
li
= ["alex", "eric"] #中括号表示列表类型 s = "**".join(li) print(s) li = ("alex", "eric"#小括号表示元祖类型 s = "**".join(li) print(s) 17,ljust 内容左对齐,右侧填充
18,rjust 内容右对齐,左侧填充
19,lstrip 移除左边的空格 示例:
s
=" alex " news = s.lstrip() print(news) 20,strip 移除两边空白 rstrip 移除右边的空格 示例:
s
=" alex " news = s.rstrip() print(news) 21,partition 从左找 ,分割,前,中,后三部分 示例:
s
= " hello is world " ret = s.partition('is') print(ret)
22,rpartition 从右找,分割,前,中,后三部分
23,replace 表示替换 示例:
s
= " hello is world " ret = s.replace('l','a') print(ret) s = " hello is world " ret = s.replace('l','a',2) #从左起到第二个 print(ret)

24,rsplit 从右找 分割

25,split 从左找 分割

  示例:

  s = "alexalexalex"

  ret = s.split("e")
  print(ret)
  运算结果:
  ['al', 'xal', 'xal', 'x']

  s = "alexalexalex"
  ret = s.split("e",2)
  print(ret)
  运算结果:
  ['al', 'xal', 'xalex']

  26,splitlines 根据换行分割

  27,startswith 是否以某个字符串开始

  28,swapcase 大写变小写,小写变大写

  示例:

  s = "aLeX"

  print(s.swapcase())
  运算结果:
  AlEx

  29,upper 变大写

 

 

 

 

基本操作:

 

1,索引

示例:
s = "hello"
print(s[0])
print(s[1])
print(s[2])
print(s[3])
print(s[4])
ret = len(s) #len 表示有几个字符串
print(ret)
运算结果:
h
e
l
l
o
5

 

2,长度

#len 表示有几个字符串
示例:
s = "hello" ret = len(s) print(ret) 运算结果: 5

 

3,切片

切片

示例:
s
= "hello" print(s[0:2]) 运算结果: he

 

4,循环

#while循环
示例:
s = "hello" start = 0 while start <len(s): temp = s[start] print(temp) start +=1 运算结果: h e l l o #for循环 #continue,break在for循环中一样适用 示例:
s = "hello" for item in s: #item变量名 print(item) 运算结果: h e l l o s = "hello" for item in s: if item =="l": continue print(item) 运算结果: h e o s = "hello" for item in s: if item =="l": break print(item) 运算结果: h e

 

 4,列表list

 源码

  1 class list(object):
  2     """
  3     list() -> new empty list
  4     list(iterable) -> new list initialized from iterable's items
  5     """在数组的末尾新增一项
  6     def append(self, p_object): # real signature unknown; restored from __doc__
  7         """
  8         L.append(object) -- append object to end """
  9         pass
 10 
 11     def count(self, value): # real signature unknown; restored from __doc__
 12         """ 查看lst中某一项出现的次数
 13         L.count(value) -> integer -- return number of occurrences of value """
 14         return 0
 15 
 16     def extend(self, iterable): # real signature unknown; restored from __doc__
 17         """将原列表与其他列表扩展成新列表
 18         L.extend(iterable) -- extend list by appending elements from the iterable """
 19         pass
 20 
 21     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
 22         """返回列表中第一个匹配项的下标,找不到会报错
 23         L.index(value, [start, [stop]]) -> integer -- return first index of value.
 24         Raises ValueError if the value is not present.
 25         """
 26         return 0
 27 
 28     def insert(self, index, p_object): # real signature unknown; restored from __doc__
 29         """在指定位置插入项
 30         L.insert(index, object) -- insert object before index """
 31         pass
 32 
 33     def pop(self, index=None): # real signature unknown; restored from __doc__
 34         """返回指定位置的值,并将其从列表中删除。默认对末尾项操作
 35         L.pop([index]) -> item -- remove and return item at index (default last).
 36         Raises IndexError if list is empty or index is out of range.
 37         """
 38         pass
 39 
 40     def remove(self, value): # real signature unknown; restored from __doc__
 41         """从列表中移除第一个符合与指定值相等的项
 42         L.remove(value) -- remove first occurrence of value.
 43         Raises ValueError if the value is not present.
 44         """
 45         pass
 46 
 47     def reverse(self): # real signature unknown; restored from __doc__
 48         """列表反转
 49         L.reverse() -- reverse *IN PLACE* """
 50         pass
 51 
 52     def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
 53         """排序,数字、字符串按照ASCII,中文按照unicode从小到大排序。
 54         L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
 55         cmp(x, y) -> -1, 0, 1
 56         """
 57         pass
 58 
 59     def __add__(self, y): # real signature unknown; restored from __doc__
 60         """ 字符串拼接
 61         x.__add__(y) <==> x+y """
 62         pass
 63 
 64     def __contains__(self, y): # real signature unknown; restored from __doc__
 65         """ 判断列表中是否包含某一项
 66         x.__contains__(y) <==> y in x """
 67         pass
 68 
 69     def __delitem__(self, y): # real signature unknown; restored from __doc__
 70         """删除列表中指定下标的项
 71         x.__delitem__(y) <==> del x[y] """
 72         pass
 73 
 74     def __delslice__(self, i, j): # real signature unknown; restored from __doc__
 75         """删除指定下标之间的内容,向下包含
 76         x.__delslice__(i, j) <==> del x[i:j]
 77                    
 78                    Use of negative indices is not supported.
 79         """
 80         pass
 81 
 82     def __eq__(self, y): # real signature unknown; restored from __doc__
 83         """ 判断两个列表是否相等
 84         x.__eq__(y) <==> x==y """
 85         pass
 86 
 87     def __getattribute__(self, name): # real signature unknown; restored from __doc__
 88         """ 无条件被调用,通过实例访问属性。
 89         x.__getattribute__('name') <==> x.name """
 90         pass
 91 
 92     def __getitem__(self, y): # real signature unknown; restored from __doc__
 93         """ x.__getitem__(y) <==> x[y] """
 94         pass
 95 
 96     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
 97         """
 98         x.__getslice__(i, j) <==> x[i:j]
 99                    
100                    Use of negative indices is not supported.
101         """
102         pass
103 
104     def __ge__(self, y): # real signature unknown; restored from __doc__
105         """ x.__ge__(y) <==> x>=y """
106         pass
107 
108     def __gt__(self, y): # real signature unknown; restored from __doc__
109         """ x.__gt__(y) <==> x>y """
110         pass
111 
112     def __iadd__(self, y): # real signature unknown; restored from __doc__
113         """ x.__iadd__(y) <==> x+=y """
114         pass
115 
116     def __imul__(self, y): # real signature unknown; restored from __doc__
117         """ 
118         x.__imul__(y) <==> x*=y """
119         pass
120 
121     def __init__(self, seq=()): # known special case of list.__init__
122         """
123         list() -> new empty list
124         list(iterable) -> new list initialized from iterable's items
125         # (copied from class doc)
126         """
127         pass
128 
129     def __iter__(self): # real signature unknown; restored from __doc__
130         """ x.__iter__() <==> iter(x) """
131         pass
132 
133     def __len__(self): # real signature unknown; restored from __doc__
134         """ x.__len__() <==> len(x) """
135         pass
136 
137     def __le__(self, y): # real signature unknown; restored from __doc__
138         """ x.__le__(y) <==> x<=y """
139         pass
140 
141     def __lt__(self, y): # real signature unknown; restored from __doc__
142         """ x.__lt__(y) <==> x<y """
143         pass
144 
145     def __mul__(self, n): # real signature unknown; restored from __doc__
146         """ x.__mul__(n) <==> x*n """
147         pass
148 
149     @staticmethod # known case of __new__
150     def __new__(S, *more): # real signature unknown; restored from __doc__
151         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
152         pass
153 
154     def __ne__(self, y): # real signature unknown; restored from __doc__
155         """ x.__ne__(y) <==> x!=y """
156         pass
157 
158     def __repr__(self): # real signature unknown; restored from __doc__
159         """ x.__repr__() <==> repr(x) """
160         pass
161 
162     def __reversed__(self): # real signature unknown; restored from __doc__
163         """ L.__reversed__() -- return a reverse iterator over the list """
164         pass
165 
166     def __rmul__(self, n): # real signature unknown; restored from __doc__
167         """ x.__rmul__(n) <==> n*x """
168         pass
169 
170     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
171         """ x.__setitem__(i, y) <==> x[i]=y """
172         pass
173 
174     def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
175         """
176         x.__setslice__(i, j, y) <==> x[i:j]=y
177                    
178                    Use  of negative indices is not supported.
179         """
180         pass
181 
182     def __sizeof__(self): # real signature unknown; restored from __doc__
183         """ L.__sizeof__() -- size of L in memory, in bytes """
184         pass
185 
186     __hash__ = None
187 
188 list         
189 
190 list Code
View Code

 

name_list = ["eirc","alex","tony"]
print(name_list)
运算结果:
['eirc', 'alex', 'tony']

 

 

基本操作:

索引
name_list = ["eirc","alex","tony"]
print(name_list[0])
运算结果:
eirc

切片
name_list = ["eirc","alex","tony"]
print(name_list[0:2])
运算结果:
['eirc', 'alex']


# len 
name_list = ["eirc","alex","tony"]
print(name_list[2:len(name_list)])
运算结果:
['tony']
# for
for i in name_list:
    print(i)
# 列表内部提供的其他功能
 

append 追加
示例:
name_list = ["eirc","alex","tony"]
name_list.append('seven')
print(name_list)
运算结果:
['eirc', 'alex', 'tony', 'seven']

示例:
name_list = ["eirc","alex","tony"]
name_list.append('seven')
name_list.append('seven')
name_list.append('seven')
name_list.append('seven')
print(name_list,count('seven'))
运算结果:
4



# iterable 可迭代的
name_list = ["eirc","alex","tony"]
temp = [11,22,33,44]
name_list.extend(temp)
print(name_list)
运算结果:
['eirc', 'alex', 'tony', 11, 22, 33, 44]

index 找出所在位子的索引
name_list = ["eirc","alex","tony"]
temp = [11,22,33,44]
name_list.extend(temp)
print(name_list.index('alex'))
运算结果:
1



insert 插入

示例:

name_list = ["eirc","alex","tony"]
temp = [11,22,33,44]
name_list.extend(temp)

name_list.insert(1,'hello')
print(name_list)
运算结果:
['eirc', 'hello', 'alex', 'tony', 11, 22, 33, 44]



pop  移除尾部的参数并且可以赋值到一个变量上a1

示例:

name_list = ["eirc","alex","tony"]
temp = [11,22,33,44]
name_list.extend(temp)

name_list.insert(1,'hello')
print(name_list)
a1 = name_list.pop()
print(name_list)

print(a1)
运算结果:
['eirc', 'hello', 'alex', 'tony', 11, 22, 33, 44]
['eirc', 'hello', 'alex', 'tony', 11, 22, 33]

44


remove 移除一个 要想都移除只能多次执行
示例:
name_list = ['eirc', 'hello','alex', 'alex', 'tony', 11, 22, 33, 44]
name_list.remove('alex')
print(name_list)
运算结果:
['eirc', 'hello', 'alex', 'tony', 11, 22, 33, 44]





reverse 翻转
示例:
name_list = ['eirc', 'hello','alex', 'alex', 'tony', 11, 22, 33, 44]
name_list.reverse()
print(name_list)
运算结果:
[44, 33, 22, 11, 'tony', 'alex', 'alex', 'hello', 'eirc']

 

del 删除一个索引
name_list = ["eirc","alex","tony"]
del name_list[1]
print(name_list)
运算结果:
['eirc', 'tony']

#切片,范围删除

name_list = ["eirc","alex","tony"]
del name_list[1:3]
print(name_list)

运算结果:

["eirc"]

 

 

 

元祖tuple

元组:

name_tuple = ('alex', 'eric')
# 索引
print(name_tuple[0])
# len
print(name_tuple[len(name_tuple)-1])
# 切片
print(name_tuple[0:1])
# for
for i in name_tuple:
print(i)
# 删除
# del name_tuple[0] 不支持
# count,计算元素出现的个数
print(name_tuple.count('alex'))
# index 获取指定元素的索引位置
print(name_tuple.index('alex'))

 

 

字典dict

字典:

name_tuple = ('alex', 'eric')
# 索引
print(name_tuple[0])
# len
print(name_tuple[len(name_tuple)-1])
# 切片
print(name_tuple[0:1])
# for
for i in name_tuple:
print(i)
# 删除
# del name_tuple[0] 不支持
# count,计算元素出现的个数
print(name_tuple.count('alex'))
# index 获取指定元素的索引位置
print(name_tuple.index('alex'))

 

 

 

 

详细请参考

http://www.cnblogs.com/wupeiqi/articles/5444685.html