python isupper返回值_Python(一、基础)

基础

# 单行注释

"""多行注释"""

"""

算数运算符

+

-

*

/

% 余数

// 整除，获取结果的整数

** 幂运算

"""

# 输出字符串

print(50 * "-")

# 变量

a = 100

b = 10.1

# 查看数据类型

#

print(type(b))

# 数据类型

"""

数字型：

整型

在2.x中整形还根据数据长度分为int和long两种

浮点型

布尔型

真True 非0数

假False 0

复数型

非数字型：

字符串

列表

元组

字典

"""

"""

1. 数字型变了之间可以直接计算(不论整型还是浮点型等等)

其中True对应数字1，False对应数字0

2. 字符串变量可以和整数使用*重复拼接

“---”×50

3. 除了上面2情况数字型变量和字符串之间不能进行任何计算(此处和java有区别)

"""

# 输入

"""

i = int(input("请输入数字： "))

print(i, type(i))

"""

# 格式化输出

"""

%s 字符串

%d 有符号十进制，%06d表示输出的整数显示位数，不足的地方使用0补全

%f 浮点数 ， %.02f表示小数点后显示两位

%% 输出%

"""

a = 10

print("取整%06d" % a) # 000010

b = 10.12

# 输出多个占位

print("保留小数点4位%.04f,%.03f" % (b, a)) # 保留小数点4位10.1200,10.000

name = "小明"

print("我的名字%s" % name)

# if判断

if a >= 18:

print("cee")

elif a < 20:

print("ce")

else:

print("haha")

# 逻辑运算符

"""

and

or

not

"""

if (True and True):

print("hehe")

# Python换行

## 原案例

if (a == 1) or (b == 2):

print("测试")

## 换行格式:添加大括号，然后or或者and换行(即每个条件换行)

if ((a == 1)

or (b == 2)):

print("测试")

# 随机数

import random

# random.randint(1,10)随机生成【1-10】都包含的随机整数

print(random.randint(1, 10))

# 赋值运算符(python中没有++这种方法)

"""

=

+=

-=

*=

/=

//=

%=

**=

"""

# print扩展

"""

print默认输出会在末尾增加换行

print("*",end=""):这样就不会换行

"""

函数

# python函数的使用必须在定义之下

def fun1(name):

print("函数" + name)

fun1("hehe")

高级数据类型

# 高级变量

"""

字符串

列表

元组

字典

在python中支持以下特点：

1.都是一个容器

2.取值[]

3.遍历for in

4. 计算长度，最大、小值 比较 删除

5. 链接+ 和重复×

6. 切片

"""

# 列表

name_list = ["a", "b"]

name_list_ex = ["e"]

## 增加

name_list.insert(1, "c")

print(name_list) # ['a', 'c', 'b']

name_list.append("d")

print(name_list) # ['a', 'c', 'b', 'd']

name_list.extend(name_list_ex)

print(name_list) # ['a', 'c', 'b', 'd', 'e']

## 修改

name_list[1] = "f"

print(name_list) # ['a', ['f'], 'b', 'd', 'e']

## 删除

del name_list[4] # 如果索引没有会越界出错

print(name_list) # ['a', 'f', 'b', 'd']

name_list.remove("a") # 删除列表中指定的第一个数据

name_list.pop() # 删除末尾数据

name_list.pop(1) # 删除制定索引的数据

# name_list.clear() # 清空列表

## 统计

len(name_list) # 列表长度

name_list.count("a") # 数据在列表中出现的次数

## 排序

name_list.sort() # 升序

name_list.sort(reverse=True) # 降序

name_list.reverse() # 逆序

# 遍历

for name in name_list:

print(name)

# 对比结果

names=["aa","bb","cc"]

for temp in names:

print(temp)

for temp in enumerate(names):

print(temp)

"""

输出结果：

aa

bb

cc

(0, 'aa')

(1, 'bb')

(2, 'cc')

"""

# 元组(元组的元素不能修改)

name_tuple = ("name", 18, 30.0)

## 元组中只包含一个元素时，需要在元素后面添加逗号

name_t1 = (1,)

print(type(name_t1)) #

print(type(1)) #

## 定义空元组

name_t2 = ()

## 取值和索引

print(name_tuple[0]) # name

print(name_tuple.index(18)) # 1

## 统计个数

print(name_tuple.count("name")) # 1

print(len(name_tuple)) # 3

for name in name_tuple:

print(name)

## 元组格式化字符串特殊用法

print("%s---%f--%d" % name_tuple) # name---18.000000--30

## 元组转换成列表

print(type(list(name_tuple))) #

## 列表转换成元组

print(type(tuple(name_list))) #

# 字典(存储无序集合)

name_dict = {"name": "小明", "age": 18}

## 取值(如果key不存在则报错)

print(name_dict["name"]) # 小明

## 增加

name_dict["sex"] = "男"

## 删除(指定key)

name_dict.pop("name")

## 统计键值对数量

print(len(name_dict)) # 2

## 合并字典(如果被合并的字典包含已经存在的键值对，则会覆盖原有的键值对)

name_d1 = {"info": "学生"}

name_dict.update(name_d1)

print(name_dict) # {'age': 18, 'sex': '男', 'info': '学生'}

## 清空字典

name_dict.clear()

## 遍历

for k in name_dict:

print(k, name_dict[k])

# 字符串(一般都用双引号，但是特殊情况下可以使用单引号)

info = "hello 'word'!"

print(info) # hello 'word'!

print(info[2]) # l

print(len(info))

print(info.count("l")) # 2

print(info.index("l")) # l字符第一次出现的索引

## 其他方法

"""

判断：

isspace: 如果字符串只包含空格，返回true

isalnum: 至少包含一个字符并且所有字符都是字母或者数字则返回true

isalpha:至少包含一个字符并且所有字符都是字母则返回true

isdecimal:只包含数字则返回true，全角数字

isdigit:只包含数字则返回true，全角数字、(1)、\u00b2

isnumeric:只包含数字返回true，全角数字，汉字数字

istitle：是标题花的(每个单词首字母大写)则返回true

islower:至少一个区分大小写的字符，并且所有这些(分区大小写的)字符都是小写，则返回true

isupper: 至少一个区分大小写的字符，并且所有这些字符都是大写，则返回true

查找和替换：

startswith:是否已开头

endswith:是否已结尾

find(str,start=0,end=len(string))检查str是否包含在string中，如果start和end制定范围，则检查是否包含制定的范围内，如果是返回开始的索引值，如果查询不到则返回-1

rfind(str,start=0,end=len(string))：类似于find，不过从右边开始查找

index(str,start=0,end=len(string)):跟find类似，只不过如果str不在string中会报错

rindex(str,start=0,end=len(string)):跟index类似，只不过从右边开始

replace(old_str,new_str,num=string.count(old)):把string中的old_str替换成new_str，如果num制定，则替换不超过num次

大小写转换

capitalize:把字符串第一个字符大写

title:把每个单词首字母大写

lower：大写字母转小写

upper：小写字母转大写

swapcase:翻转字符串中大小写

文本对齐

ljust:返回一个源字符串左对齐，并且使用空格填充至长度width的新字符串

rjust:返回一个源字符串右对齐，并且使用空格填充至长度width的新字符串

center:返回一个源字符串居中，并且使用空格填充至长度width的新字符串

去除空白字符串

lstrip:截掉string左边的空白字符串

rstrip:截掉string右边的空白字符串

strip:截掉string两边的空白字符串

拆分和连接

partition(str):把字符串分成3元素组成的元组(str前，str,str后)

rpartition(str):类似于partition只不过从右边开始查找

split(str="",num):以str为分隔符拆分string如果num有指定值，则仅分割num+1个字符串，str默认包含\r\n\t和空格

splitlines:按照\r \n \r\n分割，返回一个包含各行为元素的列表

string.join(seq):以string作为分隔符，将seq中所有的元素合并成一个新的字符串

"""

msg = "asdfjknafankjfnaskl"

## 切片，左包含右不包含

print(msg[1:10:2]) # sfkaa

print(msg[:]) # asdfjknafankjfnaskl 原样输出

print(msg[:-1]) # asdfjknafankjfnask

print(msg[-1]) # l

print(msg[::2]) # adjnfnjnsl

print(msg[2:-1]) # dfjknafankjfnask

print(msg[-2:]) # kl 最后两个字符

print(msg[0::-1]) # a

print(msg[-1::-1]) # lksanfjknafankjfdsa 逆序

# 高级数据类型的公共方法

"""

len(item):计算容器中元素格式

del(item):删除变量

max(item):返回容器中元素最大值

min(item):返回容器中元素最小值

cmp(itm1,itm2):比较两个值，-1小于/0等于/1大于 3.x中取消了该方法

"""

# 运算符

"""

+ ：字符串 列表 元组

* ： 字符串 列表 元组

in ：判断元素(key)是否存在 ： 字符串 列表 元组 字典

not in ：元素(key)是否不存在 ： 字符串 列表 元组 字典

> >= <= < == ： 元素比较 ： 字符串 列表 元组

"""

print([1, 2] * 5) # [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

# 完整for循环(即for循环内部如果满足break退出，则不执行else，其他都执行)

for a in [1, 2, 3, 4]:

print(a)

# if a==2:

# break

else:

print("没有通过break退出循环，循环结束后，会执行的代码")

函数返回值

# id(变量)：查询变量对应的地址

num = 30

print(id(num))

# 不可变类型(内存中的数据不可以被修改)

"""

数字类型 int bool float complex

字符串 str

元组 tuple

"""

# 可变类型(内存中的数据可以被修改)

"""

列表

字典

"""

# 函数内部不允许修改全局变量的值

num = 10

def n1():

"""此时相当于定义了局部变量num=99"""

num = 99

print(num)

def n3():

"""此时才是修改全局变量的值,必须分为两行写"""

global num

num = 30

print(num)

def n2():

print(num)

n1()

n3()

n2()

# 函数返回元组(如果返回元组，可以省略())

def fun():

return 1, 2

# 返回值是元组时，可以不通过下标获取，可以通过多个变量一次性接收对应数据，但是变量个数必须和元组元素个数一致

gl_one, gl_two = fun()

print(gl_one, gl_two) # 1 2

# 交换两个变量(python专有，利用元组)

# a,b=b,a

# 重点：在函数内部，针对参数使用赋值语句，不会修改到外部的实参变量，内部形参相当于内部新建一个局部变量冰指向对应内存地址

# 但是如果传入的是可变类型此时修改该地址的某个数据，则外部也变化，这和整体赋值改变是两回事

def demo(list):

list[1] = "a"

# list=[12222] 该种情况则外部数据不变

print(list) # [1, 'a', 3]

l1 = [1, 2, 3]

demo(l1)

print(l1) # [1, 'a', 3]

# 缺省参数(缺省参数必须在参数列表最末尾)

def print_info(name, sex="男", age=30):

print(name, sex, age)

# 多个缺省参数时候，具体制定参数时候需要参数名

print_info("qiang", age=40)

# 多值参数

"""

参数名前增加一个* 可以接收元组

参数名前增加两个* 可以接收字典

"""

def demo(num, *args, **kwargs):

print_info(num, args, kwargs)

demo(1, 2, 3, age=30) # 1 (2, 3) {'age': 30}

# 拆包语法，简化元组和字典的传递

demo(1, *(2, 3), **{"name": "qiang"}) # 1 (2, 3) {'name': 'qiang'}