Python

2018-02-08  本文已影响0人  阿V很简单

Python笔记

1. 文件类型

.py

.pyc

.pyo

2. 变量

命名规则:

简单理解:

3. 运算符和表达式

赋值运算符

    = 等于,赋值
    += 加等
    -= 减等
    *= 乘等
    /= 除等
    % 求余等

算术运算符

    + 加
    - 减
    * 乘
    / 除
    // 整除法
    % 求余数
    /** 幂  例如:  3**2 表示3的2平方为9

关系运算符

    <
    >
    <=
    >=
    !=
    ==

逻辑运算符

    and 逻辑与
    or 逻辑或
    not 逻辑非

表达式概念

4. 数据类型 (大部分计算机编程语言都有的定义,用一个盒子或者说空间把数据装起来)

整型 int

    a = 123
    # type() 调用该函数可得到变量的数据类型
    print(type(a))

    输出:
    <type 'int'>

长整型 long

    b = 999999999999999999999
    print(type(b))
    c = 99L
    print(type(c))
    输出:
    <type 'long'>
    <type 'long'>

浮点型 float

    d = 13.0
    print(type(d))
    e = 5.0 / 2
    print(type(e))

    输出:
    <type 'float'>
    <type 'float'>

复数类型 complex

    f = 3.14j
    print(type(f))

    输出
    <type 'complex'>

字符串 str (序列类型数据)

    # ----单引号 ''
    str1 = 'hello world'

    # ----双引号 ""
    str2 = "hello world"

    # ----注意嵌套使用,转义字符
    str3 = "hello i'm hebw"
    str4 = "hello i'm \"hebw\""

    # ----三引号 """""" 可用于保存文字的格式,如下str5等同于str6
    str5 = """Tom:
    i'm hebw,nice to see you
    ok , see you again."""
    str6 = "Tom:\n\ti'm hebw,nice to see you\n\tok , see you again."

    # 占位符的使用
    def p(x, y):
        print("%s : %s" % (x, y))
    p(1, 2)
    p(*t)

    输出:
    1 : 2

元组 tuple (序列类型数据)

列表 list (序列类型数据)

字典 dict

序列类型基本操作

索引:

序列类型容器里的元素存在索引,第一个是从0开始往后递增,
索引分正负,如下:
s = abcde
 a b c d e
 0 1 2 3 4
-5-4-3-2-1

print(s[0] + s[1])
print(s[-1] + s[-2])
输出:
ab
ed

切片:

顾名思义,截取序列数据中的一部分内容


# ----切片 [开始:结束:间隔默认为1,有调整切片方向的作用] 默认从左向右切片
# ----切片 正索引
print(s[0:1])
print(s[:4])
print(s[2:])
print(s[2::2])

输出:
a
abcd
cde
ce

# ----切片 负索引
print(s[-1])
print(s[-1:])
print(s[-1::-1])
print(s[-4:-1])
print(s[-1:-4:-1])
print(s[-2:-5:-1])

输出:
e
e
edcba
bcd
edc
dcb

长度:

str = 'abcde'
print(len(str))

输出:
5

连接:

str = 'abcde'
str2 = '12345'
print(str + str2)

输出:
abcde12345

重复:

str2 = '12345'
print(str2 * 5)

输出:
1234512345123451234512345

存在判断:

str2 = '12345'
print('1' in str2)

输出:
True

最大值:

str = 'abcde'
str2 = '12345'
print(max(str))
print(max(str2))

输出:
e
5

最小值:

str = 'abcde'
str2 = '12345'
print(min(str))
print(min(str2))

输出:
a
1

比较: 这个有点不懂?

str = 'abcde'
str2 = '12345'  
print(cmp(str, str2))
print(cmp(str, str))

输出:
1
0

遍历

list = [1, 2, 3, 4, 5, 6, 7]
str = 'hello'

# 取出序列的值
for x in list:
    print(x)
for x in str:
    print(x)

输出:
1
2
3
4
5
6
7
h
e
l
l
o

# 取出序列的索引
list = [1, 2, 3, 4, 5, 6, 7]
for x in range(len(list)):
    print(x)

输出:
0
1
2
3
4
5
6

流程控制语句

基本使用

# 两种结果
a = 15
if a > 124:
    print('a > 124')
    print('True')
else:
    print('a < 124')
    print('False')

输出:
a < 124
False

# 三种结果
a = 15
if a > 124:
    print('a > 124')
    print('ok')
elif a == 124:
    print("a == 124")
else:
    print('a < 124')
    print('false')

逻辑值

True 表示非空的量
False 表示0 NONE 空的量等

循环控制语句

else

# 循环正常结束后调用 
s = 'hello'
for k in s:
    print(k)
else:
    print("ending")

输出:
h
e
l
l
o
ending

break

# 打断此层的循环
for k in s:
    print(k)
    if k == 'l':
        break;
else:
    print("ending")

输出:
h
e
l

continue

# 跳过循环的后续代码块
for k in s:
    if k == 'l':
        continue;
    print(k)
else:
    print("ending")

输出:
h
e
o
ending

return

# 跳出循环结束函数返回数值
def ret():
    for x in 'hello':
        print(x)
        if x == 'e':
            return 1
        print('666')
    else:
        print('-----ending')


a = ret()
print(a)

输出:
e
1

while循环

# 基本使用
x = ''
while x != 'q':
    print(True)
    x = input('请输入q结束循环:')
    if not x:
        break;
    if x == 'c':
        print('one more time~~c')
else:
    print('ending')

函数

设置默认参数

def fa(name="hebw", age=0):
    print('name:%s' % name + '  age:%s' % age)
fa()

输出:
name:hebw  age:0

直接向函数传入元组

# 类似这样的函数,形式参数类似一个元组
def f(x, y):
    print x, y  
# 这里有一个元组,如何把元组直接传入方法内.分别当做x,y
t = (1, 2)
# 这里使用这个方法来直接传入一个元组 利用一个*号
f(*t)

直接向函数传入字典

def fa(name="hebw", age=0):
    print('name:%s' % name + '  age:%s' % age)
fa(**{'age': 123, 'name': 'hbwwww'})

输出:
name:hbwwww  age:123

冗余参数的接收

# 使用元组接收冗余参数

def f2(x, *args):
    print(x)
    print(args)
f2(2, 1)

输出:
2
(1,)

# 使用字典接收冗余参数

def f3(x, **args):
    print(x)
    print(args)
f3(1)
f3(1, y=1)

输出:
1
{}
1
{'y': 1}

lambda匿名函数

# 普通函数
def lam(x, y):
    return x + y
a = lam(x=1, y=2)
b = lam(*(3, 7))
print(a)
print(b)

输出:
3
10

# lambda函数
def l(x, y):
    return x * y
g = lambda x, y: x * y

print(type(g))
print(id(g))
print(g)
print(g(2, 2))

输出:
<type 'function'>
39222184
<function <lambda> at 0x0000000002567BA8>
4

# lambda用法举例
l = range(1, 6)
def fa(x, y):
    return x * y
a = reduce(fa, l)
c = reduce(lambda x, y: x * y, l)
print(a)
print(c)

输出:
120
120

switch场景,python不存在switch关键字,可以使用字典替代

# 举例 设计一个计算器

# 计算器
def add(x, y):
    return x + y


def jian(x, y):
    return x - y


def cheng(x, y):
    return x * y


def chu(x, y):
    return x / y

# 用if 和 else 写的代码
def operator(x, o, y):
    if o == "+":
        return add(x, y)
    elif o == '-':
        return jian(x, y)
    elif o == '*':
        return cheng(x, y)
    elif o == '/':
        return chu(x, y)
    else:
        pass


print(operator(6, '+', 6))

输出:
12

# 用字典的方法
oper = {"+": lambda x, y: x + y, "-": lambda x, y: x - y, "*": lambda x, y: x * y,
    '/': lambda x, y: x / y}

def fc(x, o, y):
    print(oper.get(o)(x, y))

fc(12, '/', 2)

输出:
6

# 总结:
# {}.get('o')('1', '2')
# 前面的{}代表字典,利用get方法,获取字典对应的value,value可以是一个lambda方法,同时可以直接在后传入方法的参数

内置函数

abs() 返回数字的绝对值

a = abs(-10111111)
print(a)
print(type(a))

输出:
10111111
<type 'int'>

max()最大 min()最小

l = [1, 23, 4, 5, 6, 7, 8, 9, 0, 1, 3, 23, 2, 2, 31, 5, 7, 89, 34, 23, 'sd']
print(max(l))
print(min(l))

输出:
sd
0

divmod() 返回包含两个数字的商和余的元组

print(divmod(2, 5))

输出:
(0,2)

pow(x, y[, z]) 函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

print(pow(2, 3, 4))

输出:
0

round() 四舍五入

print(round(12.4))

输出:
12.0

callable() 检测函数是否可以被调用

print(callable(round))

输出:
True

isinstance() 判断对象是否属于某类型

l2 = {1: 1, 2: 2}
print(isinstance(l2, tuple))

输出:
False

cmp() 判断两个字符串是否一样

print(cmp('1', '1'))
print(cmp('1', '2'))
print(cmp('2', '1'))

输出:
0
-1
1

xrange()相比range(),就说是效率高一点,具体用处不明啊

类型转换

print(type(int(123)))
print(type(long(123)))
print(type(float(123)))
print(type(tuple([1, 2])))
print(type(list((1,))))
print(type(str(1)))

输出:
<type 'int'>
<type 'long'>
<type 'float'>
<type 'tuple'>
<type 'list'>
<type 'str'>
上一篇下一篇

猜你喜欢

热点阅读