Learn_Day2 运算符、基本数据类型

1、编码补充

2.7版本

utf-8 ==>> gbk

utf-8解码nuicode编码gbk

1 temp = "李杰"  # utf-8
2 # 解码,需要解释原来所用编码
3 temp_unicod = temp.decode('utf-8')
4 temp_gbk = temp_unicod.encode("gbk")
5 print(temp_gbk)

编码2.7

3.5版本

utf-8编码成gbk

windows上输出：utf－8 ==>> unicode

1 temp = "李杰"
2 temp_gbk = temp.encode("gbk")
3 print(temp_gbk)
4 #b'\xc0\xee\xbd\xdc'

编码3.5

2、PyCharm全局配置（Mac）

PyCharm==>Editor==>Preferences==>File and Code Templates==>Python Script

3、运行：右键 Run

4、切换版本：

PyCharm==>Preferences==>Project:文件夹名==>Project Interpreter

5、运算符

　　- 算术运算符

加＋两个对象相加

1 n1 = 123
2 n2 = 456
3 print(n1+n2)  # 579
4 print(n1.__add__(n2))  # 579

1 a = 21
2 b = 10
3 c = 0
4 
5 c = a + b
6 print("1 - c 的值为：", c)  # 1 - c 的值为： 31

加　　　　　　

减 — 得到负数或是一个数减去另一个数

1 a = 21 
2 b = 10 
3 c = 0 
4 c = a - b 
5 print("2 - c 的值为：", c) # 2 - c 的值为： 11

减

乘＊两个对象相乘或是返回一个被重复若干次的字符串

1 a = 21
2 b = 10
3 c = 0
4 c = a * b
5 print("3 - c 的值为：", c) # 3 - c 的值为： 210

乘

除／ x除以y

1 a = 21
2 b = 10
3 c = 0
4 c = a / b 
5 print("4 - c 的值为：", c) # 4 - c 的值为： 2.1

除

1 # 2.7中计算除法需要引用(不引用只能得到整数) 
2 from __future__ import division 3 a = 9 / 2 4 print(a) # 4
3 
4 # 3.5中除法不需要引用
5 b = 9 / 2 3 print(b) # 4.5

3.7与3.5的区别

取膜％返回除法的余数

1 a = 21
2 b = 10
3 c = 0
4 c = a % b 
5 print("5 - c 的值为：", c) # 5 - c 的值为： 1

取膜

幂＊＊返回x的y的次幂

a = 2 
b = 3
c = a**b 
print("6 - c 的值为：", c) # 6 - c 的值为： 8

幂

取整除／／返回商的整数部分

1 a = 10 
2 b = 5 
3 c = a//b 
4 print("7 - c 的值为：", c) # 7 - c 的值为： 2

取整除

　　-比较运算符

等于＝＝比较对象是否相等(a == b)返回False。

1 a = 21
2 b = 10
3 c = 0
4 
5 if a == b:  # 1 - a 不等于 b
6     print("1 - a 等于 b")
7 else:
8     print("1 - a 不等于 b”)

等于

不等于 != 比较两个对象是否不相等(a != b)返回true.

1 a = 21
2 b = 10
3 c = 0
4 
5 if a != b:  # 2 - a 不等于 b
6     print("2 - a 不等于 b")
7 else:
8     print("2 - a 等于 b”)

不等于

不等于 <> 比较两个对象是否不相等(a <> b)返回true。这个运算符类似!=。

1 a = 21
2 b = 10
3 c = 0
4 
5 if a <> b:  # 3 - a 不等于 b
6     print("3 - a 不等于 b")
7 else:
8     print("3 - a 等于 b")

不等于

大于 > 返回x是否大于y(a > b)返回False。

1 a = 21
2 b = 10
3 c = 0
4 
5 if a > b:  # 5 - a 大于 b
6     print("5 - a 大于 b")
7 else:
8     print("5 - a 小于等于 b")

大于

小于 < 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。(a < b)返回true。
```
1 a = 21
2 b = 10
3 c = 0
4 if a < b:  # 4 - a 大于等于 b
5     print("4 - a 小于 b")
6 else:
7     print("4 - a 大于等于 b")
```
小于

大于等于 >= 返回x是否大于等于y。(a >= b)返回False。

1 a = 5;
2 b = 20;
3 if a <= b:  # 6 - a 小于等于 b
4     print("6 - a 小于等于 b")
5 else:
6     print("6 - a 大于  b")

大于等于

小于等于 <= 返回x是否小于等于y。

1 a = 5;
2 b = 20;
3 if b >= a:  # 7 - b 大于等于 b
4     print("7 - b 大于等于 b")
5 else:
6     print("7 - b 小于 b")

小于等于

　　-赋值运算符

＝	简单的赋值运算符	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

　-位运算符

&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

　　-逻辑运算符

and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	a or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

-成员运算符

in	not(a and b) 返回 False	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

# 2.7
a = "ren hang"
b = "ren" in a
c = "aaa" in a
print(b,c)  # True False
# 粒度不同
# 3.5
li = ["alex","abc","eric"]
d = "alex" in li
e = "al" in li
print(d,e) # True False

　　-身份运算符

is	is是判断两个标识符是不是引用自一个对象	x is y, 如果 id(x) 等于 id(y) , is 返回结果 1
not is	is not是判断两个标识符是不是引用自不同对象	x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1

　　-运算符优先级

>> <<	右移，左移运算符
&	位 'AND'
^ \|	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += = *=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

6、基本数据类型

数字 int

字符串 str

布尔值 bool

列表 list

元组 tuple

字典 dict

所有的字符串、数字、字典所具备的方法都存在相对应的“值”里

所有对象所具备的功能都存在相应的类

7、查看对象的类或对象所具备的功能（# 直接点击:鼠标直接放在要查询的功能上,(MAC版)command+左键,直接定位到功能处）

1.str，ctr＋鼠标左键，找到str类内部所有的方法

2.type

temp = "hey"
t = type(temp)  # 数据类型
print(t)  # <class 'str'>

3.dir

1 temp = "Alex"
2 t = dir(temp)  # 获取数据类型
3 print(t)  # <获取  '>

4.help，type

t = help(type(temp))
print(t)

注意：对象或类的功能后括号内为参数，括号内是self表示不传参数，参数用逗号分隔，self后有几个表示可以传几个参数，参数后有“＝”表示有默认值，可以不传参数

8、基本数据类型的常用功能

整数 int

bit_length 表示二进制最少可以占几位

1 n1 = 4
2 print(n1.bit_length())  # 3
3 # bit_length 表示二进制最少可以占几位

字符串 str：

capitalize 首字母大写

1 a = "ren hang"
2 ret = a.capitalize()
3 print(ret)
4 ＃ Ren hang

center(self,width,fillchar=None) 内容居中,width总长度，fillchar空白处填充内容：默认无
```
1 a = "ren hang"
2 ret = a.center(20, "*")
3 print(ret)
4 ＃ ******ren hang******
```

count 计数

a = "alex ren gill"
b = a.count("l")
print(b)
# 3

decode 解码

#2.7
temp = "李杰"  # utf-8
# 解码,需要解释原来所用编码
temp_unicod = temp.decode('utf-8')
# 编码
temp_gbk = temp_unicod.encode("gbk")
print(temp_gbk)

encode 编码：针对unicode

1 temp = "李杰"
2 temp_gbk = temp.encode("gbk")
3 print(temp_gbk)

endwith 以＊＊＊结尾

1 a = "alex"
2 b = a.endswith("x")
3 print(b)
4 ＃ True

expandtabs 讲tab键转换成8个空格：\t 表示tab键

1 a = "ren\thang"
2 b = a.expandtabs()
3 b2 = a.expandtabs(20)
4 print(b, b2)
5 ＃ ren     hang ren                 hang

find 找到子序列位置，找不到返回－1

1 a = "ren hang"
2 b = a.find("a")
3 b2 = a.index("n")
4 print(b, b2)
5 ＃ 5 2

format 字符格式化

a = "hello {0}, age {1}"
b = a.format("alex", 26)
print(b)
＃ hello alex, age 26

index 找到子序列位置，找不到报错（功能与find一样，忽略）

isalnum 字符串包含字母或数字

1 a1 = "renhang0214"
2 a2 = "renhang"
3 b1 = a1.isalnum()
4 b2 = a2.isalnum()
5 print(b1, b2)
6 ＃ True True

isalpha 字符串包只含字母

1 a1 = "renhang0214"
2 a2 = "renhang"
3 b1 = a1.isalpha()
4 b2 = a2.isalpha()
5 print(b1, b2)
6 ＃ False True

isdigit 字符串只包含数字

1 a1 = "renhang0214"
2 a2 = "1234"
3 b1 = a1.isdigit()
4 b2 = a2.isdigit()
5 print(b1, b2)
6 ＃ False True

islower 字符串中字母是否小写

1 a1 = "renhang0214"
2 a2 = "1234"
3 b1 = a1.islower()
4 b2 = a2.islower()
5 print(b1, b2)
6 ＃ True False

istitle 字符串是否为标题（所有首字母都大写）

a1 = "Ren Hang"
a2 = "ren Hang"
b1 = a1.istitle()
b2 = a2.istitle()
print(b1, b2)
＃ True False

isspace 判断是否为空格

1 a1 = "ren hang"
2 a2 = "renhang"
3 a3 = " "
4 b1 = a1.isspace()
5 b1 = a2.isspace()
6 b3 = a3.isspace()
7 print(b1, b2, b3)
8 ＃ False False True

isupper 字符串是否全部大写

1 a1 = "Ren Hang"
2 a2 = "REN HANG"
3 b1 = a1.isupper()
4 b2 = a2.isupper()
5 print(b1, b2)
6 ＃ False True

join(self,iterable) 连接

1 a = ["abc", "alex"]
2 b = "_".join(a)
3 print(b)
4 ＃ abc_alex

ljust 内容左侧对齐，从右侧开始填充

a = "Grissom
b = a.ljust(15, "=")
print(b)
＃ Grissom========

lower 转换成小写

1 a = "REN"
2 b = a.lower()
3 print(b)
4 ＃ ren

lstrip 移除左侧空白

1 a = "      Grissom"
2 b = a.lstrip()
3 print(b)
4 ＃ Grissom

partition 分隔成前，中后三部分，括号内为中间部分

1 a = "gissom 123 ren hang"
2 b = a.partition("123")
3 print(b)
4 ＃ ('gissom ', '123', ' ren hang')

replace 替换

1 a = "gissom 123 ren hang"
2 b = a.replace("g", "G", 1)
3 print(b)
4 ＃ Gissom 123 ren hang

rfind 从右向左找到子序列位置，找不到返回－1，使用方法与find一样
rindex 从右向左找到子序列位置，找不到报错，使用方法与index一样

rsplit 从左侧分割

1 a = "gissom gil ren hang"
2 b1 = a.rsplit("g")
3 b2 = a.rsplit("g", 2)
4 print(b1, b2)
5 ＃ ['', 'issom ', 'il ren han', ''] ['gissom ', 'il ren han', '']

rstrip 移除右侧空白

1 a = "gissom gil ren hang  "
2 b = a.rstrip()
3 print(b)
4 ＃ gissom gil ren hang

split 从右侧分割

a = "gissom gil ren hang"
b = a.split("g")
print(b)
＃ ['', 'issom ', 'il ren han', '  ']

spiltlines 按换行符分割

1 a = "gil\ngissom"
2 b = a.splitlines()
3 print(b)
4 ＃ ['gil', 'gissom']

starwith 以＊＊开头

1 a = "gissom"
2 b = a.startswith("g")
3 print(b)
4 ＃ True

strip 移除两端空白

1 a = "  gissom  "
2 b = a.strip()
3 print(b)
4 ＃ gissom

swapcse 大小写转换

1 a = "gISSOm"
2 b = a.swapcase()
3 print(b)
4 ＃ GissoM

title 把字符串变成标题

1 a = "gissom"
2 b = a.title()
3 print(b)
4 ＃ Gissom

upper 转换成大写

a = "gissom"
b = a.upper()
print(b)
＃ GISSOM

zfill 返回指定的字符串，原字符串右对齐，左侧填充

1 a = "grissom"
2 b = a.zfill(20)
3 print(b)
4 ＃ 0000000000000grissom

切片

a = "grissom"
b = a[0:2]
print(b)
＃ gr

len 字符串长度

1 a = "gissom 123"
2 b = len(a)
3 print(b)
4 ＃ 10

循环

 1 a = "grissom"
 2 # while 循环
 3 star = 0
 4 while star < len(a):
 5     temp = a[star]
 6     print(temp)
 7     star += 1
 8 """
 9 g
10 r
11 i
12 s
13 s
14 o
15 m
16 """
17 
18 # for 循环
19 for item in a:
20     print(item)
21 """
22 g
23 r
24 i
25 s
26 s
27 o
28 m
29 """
30 
31 for item in a:
32     if item == "s":
33         continue
34     print(item)
35 """
36 g
37 r
38 i
39 o
40 m
41 """
42 
43 for item in a:
44     if item == "s":
45         break
46     print(item)
47 """
48 g
49 r
50 i
51 """

循环while，for

　　列表list

 1 name_list = ["alex", "eric", "gill"]
 2 print(name_list)
 3 # 索引
 4 print(name_list[0])
 5 # 切片
 6 print(name_list[0:2])
 7 # len
 8 print(name_list[2:len(name_list)])
 9 # for
10 for i in name_list:

列表# 索引# 切片# len# f

append 追加

1 name_list = ["alex", "eric", "gill"]
2 name_list.append("R")
3 print(name_list)
4 ＃ ['alex', 'eric', 'gill', 'R']

count 统计个数

name_list = ["alex", "eric", "gill"]
b = name_list.count("alex")
print(b)
＃ 1

extend 扩展　

1 name_list = ["alex", "eric", "gill", "R"]
2 temp =[11,22,33]
3 name_list.extend(temp)
4 print(name_list)
5 ＃ ['alex', 'eric', 'gill', 'R', 11, 22, 33]

index 索引　　

1 name_list = ["alex", "eric", "gill", "R", 11, 22, 33]
2 b = name_list.index("alex")
3 print(b)
4 ＃ 0

insert 插入　　

1 name_list = ["alex", "eric", "gill", "R", 11, 22, 33]
2 b = name_list.insert(2, "grissom")
3 print(name_list)
4 ＃ ['alex', 'eric', 'grissom', 'gill', 'R', 11, 22, 33]

pop 在原列表移除并赋值给其他变量（可仅移除）

name_list = ["alex", "eric", "grissom", "gill", "R", 11, 22, 33]
b = name_list.pop()
print(name_list)
print(b)
＃ ['alex', 'eric', 'grissom', 'gill', 'R', 11, 22]
＃ 33

remove 移除某个元素

1 name_list = ['alex', 'eric', 'grissom', 'gill', 'R', 11, 22] 
2 name_list.remove(11) 
3 print(name_list) 
4 ＃ ['alex', 'eric', 'grissom', 'gill', 'R', 22]

reverse 反转

1 name_list = ["alex", "eric", "grissom", "gill", "R", 22]
2 name_list.remove(11)
3 print(name_list)
4 ＃ [22, 'R', 'gill', 'grissom', 'eric', 'alex']

del 删除

1 name_list = ["alex", "eric", "grissom", "gill", "R", 22]
2 # del 删除
3 del name_list[1]
4 print(name_list)
5 # [22, 'gill', 'grissom', 'eric', 'alex']
6 # del 删除指定索引位置
7 del name_list[1:3]
8 print(name_list)
9 # [22, 'eric', 'alex']

元组 tuple

元组与列表几乎一样；列表可以进行修改，元组不可修改

索引　　

1 name_tuple = ("alex", "eric")
2 print(name_tuple[0])
3 # alex

len 计算元组长度　　

name_tuple = ("alex", "eric")
print(name_tuple[len(name_tuple)-1])
# eric

切片

1 name_tuple = ("alex", "eric")
2 print(name_tuple[0:1])
3 # ('alex',)

for循环

1 name_tuple = ("alex", "eric")
2 for i in name_tuple:
3     print(i)
4 """
5 alex
6 eric
7 """

不支持del删除

count 计算元组个数　　

1 name_tuple = ("alex", "eric")
2 print(name_tuple.count("alex"))
3 # 1

index 获取指定元素的索引位置　

name_tuple = ("alex", "eric")
print(name_tuple.index("alex"))
# 0

字典 dict

字典的每一个元素都是键值对

索引通过key进行(取值时,key不存在,报错)　

1 user_info = {
2     "name": "alex",
3     "age": 20,
4     "gender": "M"
5 }
6 
7 print(user_info["name"])
8 # alex

循环默认输出所有key　

 1 user_info = {
 2     "name": "alex",
 3     "age": 20,
 4     "gender": "M"
 5 }
 6 
 7 for i in user_info:
 8     print(i)
 9 """
10 age
11 name
12 gender
13 """

keys 键　　

1 user_info = {
2     "name": "alex",
3     "age": 20,
4     "gender": "M"
5 }
6 
7 print(user_info.keys())
8 # dict_keys(['age', 'name', 'gender'])

values 值　　

1 user_info = {
2     "name": "alex",
3     "age": 20,
4     "gender": "M"
5 }
6 
7 print(user_info.values())
8 # dict_values([20, 'alex', 'M'])

items 键值对　

user_info = {
     "name": "alex",
     "age": 20,
     "gender": "M"
 }
 
 print(user_info.items())
#   dict_items([('age', 20), ('name', 'alex'), ('gender', 'M')])
 for k,v in user_info.items():
     print(k,v)
 """
name alex
age 20
gender M
"""

get 根据key获取值,如果key不存在,可以指定一个默认值　　

user_info = {
    "name": "alex",
    "age": 20,
    "gender": "M"
}

val = user_info.get("name")
print(val)
# alex
val2 = user_info.get("user","gr")
print(val2)
# gr

has_key 检查字典中某个指定key是否存在《2.7版本》　　
pop 获取并在字典中移除（可指定key）　　
popitem 获取并在字典中移除（移除最后一个，不可指定key）

update 更新　　

 1 user_info = {
 2     "name": "alex",
 3     "age": 20,
 4     "gender": "M"
 5 }
 6 
 7 t = {"a1": 123, "a2": 456}
 8 user_info.update(t)
 9 print(user_info)
10 # {'a2': 456, 'a1': 123, 'name': 'alex', 'age': 20, 'gender': 'M'}

del 删除　　

user_info = {
    "name": "alex",
    "age": 20,
    "gender": "M"
}

del user_info["a1"]
print(user_info)
# {'a2': 456, 'name': 'alex', 'age': 20, 'gender': 'M'}

clear 清除所有内容　　

1 user_info = {
2     "name": "alex",
3     "age": 20,
4     "gender": "M"
5 }
6 
7 user_info.clear()
8 print(user_info)
9 # {}

补充：

enumrate 为可迭代对象添加序号　　

1 li = [11, 22, 33]
2 for k, v in enumerate(li, 1):
3     print(k, v)
4 """
5 1 11
6 2 22
7 3 33
8 """

range 3.0以上版本用来获取指定范围内的数　

for i in range(1, 10):
    print(i)
    # 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

for i in range(1, 10, 2):
    print(i)
    # 结果：[1, 3, 5, 7, 9]

for i in range(30, 0, -2):
    print(i)
    # 结果：[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]

xrange 2.7版本 用来获取指定范围内的数

注意：只要能通过for循环操作的都是可迭代的

posted @ 2016-10-05 16:19 Grisom 阅读(187) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

任行

Learn_Day2 运算符、基本数据类型

公告