【JulyEdu-Python基础】第 2 课:关键字和循环控制

大纲

变量和类型
常见字符串处理
条件判断
循环控制
函数

变量和类型

基本变量类型

对于python所有对象都是继承自object的类      容器:

整数  print(type(1234))       列表     print(type([1, 2, 3, 'a', 'b']))
浮点数 print(type(123.))      元组     print(type((1, 'abc')))
字符串 print(type(123.))       集合      print(type(set(['a', 'b', 3])))
布尔值                       字典     print(type({'a': 1, 'b': 2}))
空值
函数  

def func(a, b, c):
    print(a, b, c)
    
print(type(func))
a = func
print(type(a))

模块  

import string
print(type(string))

类        

class MyClass(object):
    pass
print(type(MyClass))
my_class = MyClass()
print(type(my_class))

对于自己定义的类,它是属于type类型,(type也是一个类型,用来描述类型的类型(元编程)

  所有的类的背后也是有一个类来描述这些类的)

实例化了一个类之后,这个实例就是所对应的类型

在python里所有的对象都是类,甚至类本身也是一个类

类型*
自定义类型

变量定义

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。

x = 100

在堆上分配了一个int,4个字节,在python64位可能就8个字节,这8个字节里写了一个100,

x实际上就是指向存放100的这个内存地址。

所有的变量实际上是一个内存地址,指向堆上的一个内存地址

 

 

基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。
变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。(弱类型

变量赋值

每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。(重要!!!
等号(=)用来给变量赋值,等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。

try:
    print(x)
except NameError:
print('NameError: "x" is not defined')

 

常见字符串处理

import string
s = 'abc'
s[0] = 'x'

TypeError: 'str' object does not support item assignment

字符串可以当作一个数组访问,但是不能被修改,类型错误,不支持元素的赋值操作

去除空格及特殊符号:strip, lstrip, rstrip

import string
#去除空格
s = '   abcd  efg   '
print(s.strip())
print(s.ltrip())
print(s.rtrip())
print(s)#本身并没有被修改

在调用strip之后会返回一个新的字符串,因为字符串本身不可以被修改,

所以它调用了这种操作,修改字符串操作之后,一定是返回一个新的字符串


复制字符串:str1 = str2
连接字符串
str2 += str1
new_str = str2 + str1
查找字符串:pos = str1.index(str2)
比较字符串:cmp(str1, str2)

import string

#位置比较
s_1 = 'abcdefg'
s_2 = 'abdeffxx'
print(s_1.index('bcd'))
try:
    print(s_2.index('bcd'))
except ValueError:
    pass

在python3里面cmp函数被移除了,可以直接用> < == 比较字符串

print(s_1 == s_2)  False
print(s_1 < s_2)   True
print(s_1 > s_2)   False

字符串长度:len(str)

s = ''
if s is None:
    print('None')

空字符串和None是两回事,None是一个空指针,空字符串的话还是给它分配了一个对象,

在内存中还是有一个对象的,但是空字符串和False是等价的

s = ''
if s is None:
    print('None')
if not s:
    print('Empty')

大小写转换
u_str = str.upper()
l_str = str.lower()
首字母大写:str.capitalize(); string.capword(str)

import string

#大小写
s = "abc def"
print(s.upper())
print(s.upper().lower())
print(s.capitalize())

 

分割与合并字符串:split, splitlines, join

#分割和连接
s='abc,def,ghi'
splitted = s.split(',')
print(type(splitted))
print(splitted)
s = """abc
def
ghi
efg"""
s_1 = s.split('\n')
s_2 = s.splitlines()#按行分割
print(s_1)
print(s_2)

print(''.join(s_1))
print('-'.join(s_1))
print('\n'.join(s_1))

 

类型转换:int, float转换

#数字转换成字符串
print(str(5))
print(str(5.))
print(str(5.1234))
print(str(-5.123))
#字符串到数字
print(int('1234'))
print(float('1234.45'))
print(int('123.45'))
print(int('123.45'))要传递正确的格式,如果格式错误,系统不会自动认为你是一个浮点数要转换成整数
#几进制的转换
print(int('110111', 2))#2进制转换成10进制
print(int('ffff', 16))#16进制转换成10进制
print(int('7777', 8))
#由于字符串本身不可以被修改,
#把字符串赋值到数组里面去
s = "abcdefg"
l = list(s)
print(l)

作业:

字符串按单词反转,必须保留所有空格('I love China!  ')

格式化字符串

字符串测试
str.startswith(prefix)
str.endswith(suffix)
str.isalnum() # 是否全是字母和数字,并至少有一个字符。
str.isalpha() # 是否全是字母,并至少有一个字符。
str.isdigit() # 是否全是数字,并至少有一个字符。
str.isspace() # 是否全是空白字符,并至少有一个字符。
str.islower() # 字母是否全是小写
str.isupper() # 字母是否全是大写
str.istitle() # 首字母是否大写

#常用判断
s = "abcdefg"
print(s.startswith('abc'))
print(s.endswith('efg'))
print('1234abcd'.isalnum())
print('\t34abcd'.isalnum())  #False
print('1234'.isdigit())
print('abcd'.isalpha())
print('   '.isspace())
print('abcd12345'.islower())
print('ABCD1234'.isupper())
print('Hello world'.istitle())  #False
#istitle()如果字符串中所有的单词拼写首字母是否为大写,且其他字母为小写则返回 True,否则返回 False.

 

条件判断

python 中没有switch函数的只能有if elif else来完成

真值判断
if x == True:
if x:
if not x:

#if判断
a = 100
b = 200
c = 300
if c == a:
    print(a)
elif c == b:
    print(c)
else:
    print(b)

空值判断
if x is None:
if not x:

#None的判断
x = None
if x is None:
    print('None')
else:
    print('not None')

比较
if a == b:
if a > b:
...

 

循环控制

for循环
for i in range(begin, end, steps): <=> for (i = begin; i < end; i += steps)
while循环
while 条件判断:
循环嵌套
循环控制
break
continue
pass

 

# for 循环
#for (i = start; i < end; i += step)

#for i in 容器(可迭代的)

for i in range(0,30, 5):
    print (i) 

# while 循环

s = 0
i = 1
while i <= 100:
    s += i
    i += 1

print (s)

for i in range(0,100):
    if i < 10:
        pass
    elif i < 30:
        continue
    elif i < 35:
        print(i)
    else:
        break

 

函数

def func_name(arg_1, arg_2):
    print (arg_1, arg_2)
    return arg_1, arg_2#返回多个值,实际返回的是一个元组,只读的list

r = func_name(1, 2)
print(type(r))
print(r)
print(r[0], r[1])

函数定义格式

  默认参数

def func(x, y = 500):
    return x + y

print(func(100, 600))  
print(func(100))

  

def func(x, y = 500):
    print('x=', x)
    print('y=', y)
    return x + y

print(func(100))
print(func(y = 300, x = 200))
print(func(x = 400))

在函数调用的时候,把参数的名字给写出来,并给它指定一个值,

不用严格按照参数次序,代码的可读性提高

def func(p):
    print('x=', p['x'])
    print('y=', p['y'])

print(func({'x':100, 'y':200}))#用字典实现类似的功能

  可变参数:*args,自动组装成tuple

#可变参数

#main(int argc, char ** argv)
#printf

def func(name, *numbers):
    print(type(numbers))

func('Tom', 1, 2, 3, 4, 5)

从name之后,后面所有的参数,它会打包成一个元组,一个只读的数组

#tuple - 元组  <=>   只读数组,后面的所有参数都会作为一个数组

*numbers前面加一个*号,告诉python处理后面所有参数时,放到一个数组里面去
def func(name, *numbers):
    print(numbers)
    print(numbers[0])  #1
    print(numbers[3])  #4
    return 'Done'
func('Tom', 1, 2, 3, 4, 5, 'abc', 'def')

容器是不用考虑类型一致性,计算的时候才会有要求

可变参数是没有名字的,只能有数组索引,python提供另一种方法,

传入字典  使用 **

def my_print(*args):
    print(args)

my_print(1, 2, 3, 4, 'a', 'b', 'c')

def func(name, **kvs): # ** means key/values
    print(name)
    print(type(kvs))
    print(kvs)
func('Tom', china = 'Beijing', uk = 'London')
<class 'dict'>
{'china': 'Beijing', 'uk': 'London'}


  关键字参数:*args,自动组装成dict
  命名关键字参数

def func(a, b, c, *, china, uk):
    print(china, uk)
func(1, 2, 3, china = 'Beijing', uk = 'London')

* 号后面的变量,意味着在传递参数的时候,一定要把它的名字带上

def func(a, b, c = 0, *args, ** kvs):
    print(a, b, c)
    print(args)
    print(kvs)

func(1, 2)
func(1, 2, 3)
func(1, 2, 3, 'a','b', 'c')
func(1, 2, 3, 'a', 'b', china = 'BJ', uk = 'LD')

#为了代码可读性高一些,*代表传递给args
func(1, 2, 3, *('a', 'b'), **{'china' : 'BeiJing', 'uk' : 'London'})
1 2 0
()
{}
1 2 3
()
{}
1 2 3
('a', 'b', 'c')
{}
1 2 3
('a', 'b')
{'china': 'BJ', 'uk': 'LD'}
1 2 3
('a', 'b')
{'china': 'BeiJing', 'uk': 'London'}
def my_print(*args):
    print(*args)

my_print('x=', 100, ';y=', 200)
x= 100 ;y= 200

作业:

打印100000以内的所有素数

自己实现一个函数支持可变参数



函数调用
  函数名(参数名)
  模块名.函数名(参数名)
  带参数名调用
什么是递归?

def my_sum(i):
    if i < 0:
        raise ValueError
    elif i <= 1:
        return i 
    else:
        return i + my_sum(i-1)

print(my_sum(1))
print(my_sum(2))
print(my_sum(3))
print(my_sum(4))
print(my_sum(100))
1
3
6
10
5050

斐波那契数

#f(n) = f(n-1) + f(n-2)

def fib(n):
    if n < 1:
        raise ValueError
    elif n <= 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)

print(fib(1))
print(fib(2))
print(fib(3))
print(fib(4))
print(fib(5))
print(fib(6))
1
1
2
3
5
8
def hanoi(n, source, target, helper):
    if n == 1:
        print(source + '->' + target)
    else:
        hanoi(n-1, source, helper, target)
        print(source + '->' + target)
        hanoi(n-1, helper, target, source)

hanoi(4, 'A', 'B', 'C')
A->C
A->B
C->B
A->C
B->A
B->C
A->C
A->B
C->B
C->A
B->A
C->B
A->C
A->B
C->B

 

# 在python里函数是可以作为参数的

p = print
p(1,2,3)

def sum(x, y, pf = None):
    s = x + y
    if pf:
        pf(s)
    return s

sum(100, 200)
sum(100, 200, print)

def cmp(x, y, cp = None):
    if not cp:
        if x > y:
            return 1
        elif x < y:
            return -1
        else:
            return 0
    else:
        return cp(x, y)

def my_cp(x, y):
    if x < y:
        return 1
    elif x == y:
        return 0
    else:
        return -1

print(cmp(100,200))
print(cmp(100, 200, my_cp))

 

1 2 3
300
-1
1

作业:

  字符串按单词反转(必须保留所有空格):'I love China!   ' 转化为 '   China! love I'

  打印100000以内的所有素数

  自己实现一个函数支持可变参数

  自己实现函数解决hanoi塔问题

  实现一个sort函数,通过参数指定比较函数用来实现按不同顺序进行排序


 

在python里面,因为函数本身也是一个对象,所以它可以像普通变量一样,被作为参数传递来传递去

def do_sum(data, method):
    return method(data)

print(do_sum([1, 2, 3, 4], sum))

 

 

 

你可能感兴趣的:(【JulyEdu-Python基础】第 2 课:关键字和循环控制)