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

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

大纲

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

变量和类型

基本变量类型

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

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

def func(a, b, c):

    print(a, b, c)

print(type(func))
a = func
print(type(a))

模块　　<class 'module'>

import string

print(type(string))

类　　　　<class 'type'>　　　　<class '__main__.MyClass'>

class MyClass(object):

    pass

print(type(MyClass))

my_class = MyClass()

print(type(my_class))

对于自己定义的类，它是属于ｔｙｐｅ类型，（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是一个空指针，空字符串的话还是给它分配了一个对象，

在内存中还是有一个对象的，但是空字符串和Ｆａｌｓｅ是等价的

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(''))

print(float('1234.45'))

print(int('123.45'))

print(int('123.45'))要传递正确的格式，如果格式错误，系统不会自动认为你是一个浮点数要转换成整数

#几进制的转换

print(int('', 2))#2进制转换成10进制

print(int('ffff', 16))#16进制转换成10进制

print(int('', 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(''.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

作业：

打印１０００００以内的所有素数

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

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

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))

斐波那契数

#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))

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))

作业：

字符串按单词反转（必须保留所有空格）：'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))

正文

大纲

变量和类型

基本变量类型

变量定义

变量赋值

常见字符串处理

import string
s = 'abc'
s[0] = 'x' TypeError: 'str' object does not support item assignment

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

条件判断

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

函数

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])

相关阅读

sqlserver搜索jsp，sqlserver搜索关键字

查找包含关键字的数据表名称mysql，mysql查询包含关键字命令

mysql给已有字段设置默认值的表是，mysql设置表的默认字符集关键字是

mysql数据库表查询关键字，mysql关联查询关键字

mysql字段碰到关键字，mysql的关键字

mysql从关键字后几位截取字符串，mysql从某个字符开始截取

mysql创建唯一索引的关键字，mysql数据库唯一索引创建

面向对象的关键字含义，面向对象方法中的关系

目录[+]

大纲

变量和类型

基本变量类型

变量定义

变量赋值

常见字符串处理 import string s = 'abc' s[0] = 'x' TypeError: 'str' object does not support item assignment 字符串可以当作一个数组访问,但是不能被修改，类型错误，不支持元素的赋值操作

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

函数 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])

相关阅读

sqlserver搜索jsp，sqlserver搜索关键字

查找包含关键字的数据表名称mysql，mysql查询包含关键字命令

mysql给已有字段设置默认值的表是，mysql设置表的默认字符集关键字是

mysql数据库表查询关键字，mysql关联查询关键字

mysql字段碰到关键字，mysql的关键字

mysql从关键字后几位截取字符串，mysql从某个字符开始截取

mysql创建唯一索引的关键字，mysql数据库唯一索引创建

面向对象的关键字含义，面向对象方法中的关系

目录[+]

常见字符串处理

import string
s = 'abc'
s[0] = 'x' TypeError: 'str' object does not support item assignment

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

条件判断

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

函数

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])